掌握 C# 设计模式：从基础到依赖注入

设计模式是一种可以在开发中重复使用的解决方案，能够提高代码的可维护性、扩展性和复用性。C# 中常见的设计模式包括单例模式、工厂模式、观察者模式、策略模式等。本文将介绍这些常见的设计模式，并探讨 SOLID 原则和依赖注入（Dependency Injection）的重要性。

---

1. 常见设计模式

单例模式（Singleton）

单例模式 确保一个类只有一个实例，并提供全局访问点。它在需要共享资源或控制全局状态的情况下非常有用。

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

    private Singleton() { }

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

在上面的例子中，Singleton 类通过静态 Instance 属性保证全局唯一性，并使用双重锁定确保线程安全。

工厂模式（Factory）

工厂模式 提供了一种创建对象的接口，而不是直接实例化类。它将对象的创建与业务逻辑解耦。

public interface IProduct
{
    void Create();
}

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

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

public class ProductFactory
{
    public static IProduct GetProduct(string type)
    {
        return type switch
        {
            "A" => new ConcreteProductA(),
            "B" => new ConcreteProductB(),
            _ => throw new ArgumentException("Invalid product type")
        };
    }
}

在这个示例中，工厂方法 GetProduct 负责创建 ConcreteProductA 或 ConcreteProductB，而客户端无需知道具体实现细节。

观察者模式（Observer）

观察者模式 定义了对象间的一对多依赖关系，当一个对象的状态改变时，依赖它的对象会收到通知并自动更新。这个模式常用于事件驱动的系统中。

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()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

public interface IObserver
{
    void Update();
}

public class ConcreteObserver : IObserver
{
    public void Update() => Console.WriteLine("Observer notified");
}

在这个示例中，Subject 维护了一个观察者列表，状态改变时，Notify 方法通知所有观察者。

策略模式（Strategy）

策略模式 允许在运行时选择算法或策略，避免在代码中使用大量的条件语句。每个策略都是一个独立的类，封装了具体的算法或行为。

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute() => Console.WriteLine("Executing Strategy A");
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute() => Console.WriteLine("Executing Strategy B");
}

public class Context
{
    private IStrategy strategy;
    public Context(IStrategy strategy) => this.strategy = strategy;

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

在这个示例中，Context 类根据不同的策略执行相应的算法，策略可以在运行时动态选择。

---

2. SOLID 原则

SOLID 是面向对象设计的五大原则，旨在提高代码的可维护性和扩展性。这五个原则包括：

• S：单一职责原则（Single Responsibility Principle）
  • 一个类应该只有一个职责。
• O：开闭原则（Open/Closed Principle）
  • 软件实体应该对扩展开放，对修改关闭。
• L：里氏替换原则（Liskov Substitution Principle）
  • 子类对象应该可以替换父类对象，并且不会导致错误。
• I：接口隔离原则（Interface Segregation Principle）
  • 接口应该小而专，避免臃肿的接口。
• D：依赖倒置原则（Dependency Inversion Principle）
  • 高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

这些原则确保代码设计更加清晰、灵活，并且容易扩展。例如，遵循单一职责原则可以避免一个类承担太多职责，增加了代码的可维护性；而开闭原则确保我们可以在不修改现有代码的情况下进行功能扩展。

---

3. 依赖注入（Dependency Injection）

依赖注入 是实现 SOLID 原则（尤其是依赖倒置原则）的重要手段。它允许我们将类的依赖项通过外部注入，而不是让类自行实例化依赖项，从而提高代码的可测试性和灵活性。

构造函数注入

public interface IService
{
    void Serve();
}

public class Service : IService
{
    public void Serve() => Console.WriteLine("Service Called");
}

public class Client
{
    private readonly IService service;

    public Client(IService service)
    {
        this.service = service;
    }

    public void Start() => service.Serve();
}

在这个示例中，Client 类不直接依赖 Service 类，而是依赖于 IService 接口，通过构造函数将实现传递给 Client，使得 Client 更加灵活。

使用依赖注入框架

在 C# 中，通常会使用依赖注入框架（如 ASP.NET Core 的内置 DI 容器）来自动管理依赖关系。

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<IService, Service>();
    services.AddTransient<Client>();
}

通过 DI 容器，可以自动解析依赖项并注入到构造函数中，无需手动实例化对象。这种方式极大简化了对象的管理，提升了可维护性和可测试性。

---

结论

设计模式和 SOLID 原则是提高代码质量、灵活性和可扩展性的有效工具。通过合理运用设计模式，我们可以解决常见的开发问题，简化系统的设计。SOLID 原则确保我们的代码结构更加清晰，避免复杂的耦合和难以维护的代码。

• 单例模式：控制类的实例数量，适用于全局唯一对象。
• 工厂模式：通过工厂类创建对象，解耦了对象的创建和使用。
• 观察者模式：使得对象间的变化可以被自动通知，适用于事件驱动的场景。
• 策略模式：允许动态选择行为或算法，避免条件判断过多的代码。
• SOLID 原则 提高了代码设计的健壮性。
• 依赖注入：通过外部注入依赖项，减少了类之间的耦合。

掌握这些设计模式和原则可以显著提升开发效率和代码质量。如果你有更多关于设计模式或依赖注入的疑问，欢迎继续探讨！

---

这篇博客为你介绍了常见的设计模式、SOLID 原则以及依赖注入的相关概念。如果你有任何问题或需要具体的实现示例，欢迎联系我！