C#学习第23天：面向对象设计模式

什么是设计模式？

• 定义：设计模式是软件开发中反复出现的特定问题的解决方案。它们提供了问题的抽象描述和解决方案。
• 目的：通过提供成熟的解决方案，设计模式可以加快开发速度并提高代码质量。

常见的设计模式 

设计模式通常分为三大类：创建型模式、结构型模式和行为型模式。

创建型模式

1.单例模式（Singleton Pattern）

• 目的：确保一个类只有一个实例，并提供一个全局访问点。
• 应用：用于管理共享资源，如配置类、日志记录类等。

public class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

// padlock 是一个线程同步锁对象
// 1. 用于确保在多线程环境下,同一时间只有一个线程可以访问 Instance 属性
// 2. 防止多个线程同时创建单例实例,避免产生多个实例
// 3. lock(padlock) 会在代码块执行期间锁定 padlock 对象
// 4. 其他试图访问这个被锁定代码块的线程将被阻塞,直到锁被释放
// 5. readonly 确保 padlock 对象在运行时不会被修改,增加了线程安全性

// 单例模式示例调用代码
public class SingletonDemo
{
    public static void Run()
    {
        // 获取单例实例
        Singleton instance1 = Singleton.Instance;
        Singleton instance2 = Singleton.Instance;

        // 验证是否是同一个实例
        bool isSameInstance = ReferenceEquals(instance1, instance2);
        Console.WriteLine($"instance1 和 instance2 是否是同一个实例: {isSameInstance}");
        
        // 多线程测试
        Parallel.For(0, 10, i =>
        {
            Singleton instance = Singleton.Instance;
            Console.WriteLine($"线程 {i} 获取的实例: {instance.GetHashCode()}");
        });
    }
}

 2.工厂模式（Factory Pattern）

• 目的：定义一个用于创建对象的接口，让子类决定实例化哪个类。
• 应用：适合用于需要灵活创建对象的场景，隐藏复杂的创建逻辑。

public interface IProduct
{
    void Use();
}

public class ConcreteProductA : IProduct
{
    public void Use() => Console.WriteLine("Using Product A");
}

public class ConcreteProductB : IProduct
{
    public void Use() => Console.WriteLine("Using Product B");
}

public class ProductFactory
{
    public IProduct CreateProduct(string type)
    {
        if (type == "A")
            return new ConcreteProductA();
        if (type == "B")
            return new ConcreteProductB();
        // 可以扩展其他产品
        throw new ArgumentException("Invalid type");
    }
}

结构型模式

1.适配器模式（Adapter Pattern）

• 目的：将一个类的接口转换为客户期望的另一个接口，使得原本不兼容的类可以一起工作。
• 应用：用于集成第三方库或遗留系统。

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest() => Console.WriteLine("Specific Request");
}

public class Adapter : ITarget
{
    private Adaptee adaptee = new Adaptee();

    public void Request() => adaptee.SpecificRequest();
}

 2.装饰器模式（Decorator Pattern）

• 目的：动态地给对象添加职责。
• 应用：用于需要动态地添加功能的场合，而不影响其他对象的使用。

public abstract class Component
{
    public abstract void Operation();
}

public class ConcreteComponent : Component
{
    public override void Operation() => Console.WriteLine("ConcreteComponent Operation");
}

public abstract class Decorator : Component
{
    protected Component component;

    public void SetComponent(Component component)
    {
        this.component = component;
    }

    public override void Operation()
    {
        if (component != null)
        {
            component.Operation();
        }
    }
}

public class ConcreteDecorator : Decorator
{
    public override void Operation()
    {
        base.Operation();
        AddedBehavior();
    }

    void AddedBehavior()
    {
        Console.WriteLine("ConcreteDecorator Added Behavior");
    }
}

// 装饰器模式示例调用代码
public class DecoratorDemo
{
    public static void Run()
    {
        // 创建具体组件
        var component = new ConcreteComponent();
        
        // 创建装饰器
        var decorator = new ConcreteDecorator();
        
        // 设置装饰器的组件
        decorator.SetComponent(component);
        
        // 调用装饰后的操作
        decorator.Operation();
        // 输出:
        // ConcreteComponent Operation
        // ConcreteDecorator Added Behavior
    }
}

 行为型模式

1.观察者模式（Observer Pattern）

• 目的：定义对象间的一对多依赖，当一个对象改变状态时，所有依赖的对象都会被通知并自动更新。
• 应用：适用于事件驱动的编程中，如GUI控件事件。

public interface IObserver
{
    void Update(string message);
}

public class ConcreteObserver : IObserver
{
    private string name;

    public ConcreteObserver(string name)
    {
        this.name = name;
    }

    public void Update(string message) => Console.WriteLine($"{name} 收到消息: {message}");
}

public class Subject
{
    private List<IObserver> observers = new List<IObserver>();

    public void Attach(IObserver observer) => observers.Add(observer);
    public void Detach(IObserver observer) => observers.Remove(observer);

    public void Notify(string message)
    {
        foreach (var observer in observers)
        {
            observer.Update(message);
        }
    }
}

// 示例调用代码
public class ObserverDemo
{
    public static void Run()
    {
        // 创建主题
        var subject = new Subject();

        // 创建观察者
        var observer1 = new ConcreteObserver("观察者1");
        var observer2 = new ConcreteObserver("观察者2");
        var observer3 = new ConcreteObserver("观察者3");

        // 注册观察者
        subject.Attach(observer1);
        subject.Attach(observer2);
        subject.Attach(observer3);

        // 发送通知
        subject.Notify("系统更新完成");

        // 移除一个观察者
        subject.Detach(observer2);

        // 再次发送通知
        subject.Notify("新消息到达");
    }
}

2.策略模式（Strategy Pattern）

• 目的：定义一系列算法，将每个算法封装起来，并使它们可以互换。
• 应用：用于消除条件语句，并在运行时更改算法。

public interface IStrategy
{
    void Execute();                // 执行策略      
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute() => Console.WriteLine("执行策略A");
}

public class ConcreteStrategyB : IStrategy    
{
    public void Execute() => Console.WriteLine("执行策略B");
}

public class Context
{
    private IStrategy strategy;

    public Context(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy) => this.strategy = strategy;

    public void ExecuteStrategy() => strategy.Execute();    
}

// 策略模式示例调用代码
public class StrategyDemo 
{
    public static void Run()
    {
        // 创建具体策略对象
        var strategyA = new ConcreteStrategyA();
        var strategyB = new ConcreteStrategyB();

        // 创建上下文并设置初始策略
        var context = new Context(strategyA);
        
        // 执行策略A
        context.ExecuteStrategy();

        // 切换到策略B
        context.SetStrategy(strategyB);
        
        // 执行策略B
        context.ExecuteStrategy();
    }
}

使用场景

代码重用与扩展：

• 设计模式提供了可重用的代码解决方案，可方便地扩展功能。

降低耦合度：

• 通过将行为或功能解耦并封装在独立的类中，设计模式降低了系统的耦合性。

提高可维护性：

• 清晰的设计模式使得代码更易于理解和维护。

通过理解和使用设计模式，您可以更有效地解决复杂的软件设计问题，提高代码的质量和可维护性。如果有任何问题或者需要进一步指导，请随时告诉我！