C# 设计模式（一） 单例模式、工厂模式、观察者模式、策略模式

C# 设计模式

设计模式是一种经过实践证明的通用的解决问题的方案。在软件开发中，设计模式可以帮助开发人员更好地组织和管理代码，提高代码的可读性、可维护性和可扩展性。C# 是一种强类型、面向对象的编程语言，具有良好的扩展性和可靠性。在 C# 开发中，设计模式也是非常重要的一部分。

在本文中，我们将介绍一些常用的 C# 设计模式，并解释它们的工作原理和实际应用场景。

单例模式

单例模式是一种创建型模式，它保证一个类只有一个实例，并提供一个全局访问点。在 C# 中，我们可以使用静态变量或者静态属性来实现单例模式。以下是一个简单的单例模式实现：

public class Singleton
{
    private static Singleton instance = null;

    private Singleton() { }

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

在上面的代码中，我们使用了一个私有的构造函数，这样就禁止了其他对象创建该类的实例。同时，我们使用了一个静态变量 instance 来保存类的唯一实例。在 Instance 属性中，我们检查 instance 是否为 null，如果是，则创建一个新的实例，否则直接返回已有的实例。

单例模式的应用场景比较广泛，比如数据库连接池、日志记录器等。

工厂模式

工厂模式是一种创建型模式，它提供了一种创建对象的接口，但是具体的对象创建过程由子类决定。在 C# 中，我们可以使用抽象类或者接口来定义工厂类。以下是一个简单的工厂模式实现：

public interface IProduct
{
    void Operation();
}

public class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine("ConcreteProductA.Operation");
    }
}

public class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine("ConcreteProductB.Operation");
    }
}

public abstract class Factory
{
    public abstract IProduct CreateProduct();
}

public class ConcreteFactoryA : Factory
{
    public override IProduct CreateProduct()
    {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB : Factory
{
    public override IProduct CreateProduct()
    {
        return new ConcreteProductB();
    }
}

在上面的代码中，我们定义了一个 IProduct 接口，其中包含了一个 Operation 方法。同时，我们定义了两个实现了 IProduct 接口的具体产品类 ConcreteProductA 和 ConcreteProductB。我们还定义了一个抽象工厂类 Factory，其中包含了一个抽象的 CreateProduct 方法。最后，我们定义了两个具体的工厂类 ConcreteFactoryA 和 ConcreteFactoryB，分别实现了 CreateProduct 方法来创建 ConcreteProductA 和 ConcreteProductB。

工厂模式的应用场景包括但不限于：窗口控件创建、日志记录器创建等。

观察者模式

观察者模式是一种行为型模式，它定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，它的所有依赖者都会得到通知并自动更新。在 C# 中，我们可以使用事件和委托来实现观察者模式。以下是一个简单的观察者模式实现：

public class Subject
{
    private List<Observer> observers = new List<Observer>();
    private int state;

    public int State
    {
        get { return state; }
        set
        {
            state = value;
            NotifyAllObservers();
        }
    }

    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }

    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }

    public void NotifyAllObservers()
    {
        foreach (Observer observer in observers)
        {
            observer.Update();
        }
    }
}

public abstract class Observer
{
    protected Subject subject;

    public Observer(Subject subject)
    {
        this.subject = subject;
    }

    public abstract void Update();
}

public class ConcreteObserverA : Observer
{
    public ConcreteObserverA(Subject subject) : base(subject) { }

    public override void Update()
    {
        Console.WriteLine("ConcreteObserverA: " + this.subject.State);
    }
}

public class ConcreteObserverB : Observer
{
    public ConcreteObserverB(Subject subject) : base(subject) { }

    public override void Update()
    {
        Console.WriteLine("ConcreteObserverB: " + this.subject.State);
    }
}

在上面的代码中，我们定义了一个 Subject 类，其中包含了一些观察者对象，并且具有一个 State 属性，当 State 发生改变时，会通知所有观察者。我们还定义了一个 Observer 抽象类，其中包含了一个 Update 方法，用于更新观察者状态。最后，我们定义了两个具体的观察者类 ConcreteObserverA 和 ConcreteObserverB，它们继承自 Observer 类，并实现了 Update 方法。

观察者模式的应用场景比较广泛，比如事件处理、GUI 编程等。

策略模式

策略模式是一种行为型模式，它定义了一系列算法，将每个算法封装起来，使它们可以互换。在 C# 中，我们可以使用委托来实现策略模式。以下是一个简单的策略模式实现：

public delegate void Strategy();

public class Context
{
    private Strategy strategy;

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

    public void ExecuteStrategy()
    {
        strategy();
    }
}

public class ConcreteStrategyA
{
    public void Execute()
    {
        Console.WriteLine("ConcreteStrategyA.Execute");
    }
}

public class ConcreteStrategyB
{
    public void Execute()
    {
        Console.WriteLine("ConcreteStrategyB.Execute");
    }
}

在上面的代码中，我们定义了一个 Strategy 委托，它表示一个算法。我们还定义了一个 Context 类，它包含了一个 Strategy 委托，用于执行具体的算法。最后，我们定义了两个具体的算法类 ConcreteStrategyA 和 ConcreteStrategyB，它们都实现了 Strategy 委托。

策略模式的应用场景包括但不限于：排序算法、加密算法等。

总结

C# 设计模式是一种实践证明的通用解决问题的方案，它可以帮助开发人员更好地组织和管理代码，提高代码的可读性、可维护性和可扩展性。本文介绍了一些常用的 C# 设计模式，包括单例模式、工厂模式、观察者模式和策略模式。这些模式在实际项目中都有广泛的应用，开发人员可以根据实际情况选择合适的模式来解决问题。