设计模式(温故而知新)

C# 设计模式

设计模式是软件设计中常见问题的可重用解决方案，它们代表了最佳实践，是经验丰富的开发人员的经验总结。以下是C#中常用的设计模式分类和示例：

创建型模式

1. 单例模式 (Singleton)

public sealed class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();
    
    private Singleton() { }
    
    public static Singleton Instance
    {
        get
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
                return _instance;
            }
        }
    }
}

2. 工厂方法模式 (Factory Method)

public interface IProduct
{
    string Operation();
}

public class ConcreteProductA : IProduct
{
    public string Operation() => "Result of ConcreteProductA";
}

public abstract class Creator
{
    public abstract IProduct FactoryMethod();
    
    public string SomeOperation()
    {
        var product = FactoryMethod();
        return $"Creator: {product.Operation()}";
    }
}

public class ConcreteCreatorA : Creator
{
    public override IProduct FactoryMethod() => new ConcreteProductA();
}

3. 抽象工厂模式 (Abstract Factory)

public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA() => new ConcreteProductA1();
    public IAbstractProductB CreateProductB() => new ConcreteProductB1();
}

结构型模式

4. 适配器模式 (Adapter)

public interface ITarget
{
    string GetRequest();
}

public class Adaptee
{
    public string GetSpecificRequest() => "Specific request";
}

public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;
    
    public Adapter(Adaptee adaptee) => _adaptee = adaptee;
    
    public string GetRequest() => $"This is '{_adaptee.GetSpecificRequest()}'";
}

5. 装饰器模式 (Decorator)

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

public class ConcreteComponent : Component
{
    public override string Operation() => "ConcreteComponent";
}

public abstract class Decorator : Component
{
    protected Component _component;
    
    public Decorator(Component component) => _component = component;
    
    public override string Operation() => _component?.Operation();
}

public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(Component comp) : base(comp) { }
    
    public override string Operation() => $"ConcreteDecoratorA({base.Operation()})";
}

行为型模式

6. 观察者模式 (Observer)

public interface IObserver
{
    void Update(ISubject subject);
}

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public class Subject : ISubject
{
    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(this);
        }
    }
}

7. 策略模式 (Strategy)

public interface IStrategy
{
    object DoAlgorithm(object data);
}

public class Context
{
    private IStrategy _strategy;
    
    public Context(IStrategy strategy) => _strategy = strategy;
    
    public void SetStrategy(IStrategy strategy) => _strategy = strategy;
    
    public void DoSomeBusinessLogic() => _strategy.DoAlgorithm("data");
}

C# 特有模式

8. 依赖注入模式 (Dependency Injection)

public interface IService
{
    void Serve();
}

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

public class Client
{
    private IService _service;
    
    public Client(IService service) => _service = service;
    
    public void Start() => _service.Serve();
}

// 使用:
// var client = new Client(new Service());
// client.Start();

9. 异步编程模式 (Async/Await)

public async Task<string> GetDataAsync()
{
    using (var httpClient = new HttpClient())
    {
        return await httpClient.GetStringAsync("https://example.com");
    }
}

设计模式选择建议

1. 创建对象：考虑工厂方法、抽象工厂、建造者或原型模式
2. 对象结构：考虑适配器、桥接、组合、装饰器、外观、享元或代理
3. 对象行为：考虑责任链、命令、解释器、迭代器、中介者、备忘录、观察者、状态、策略、模板方法或访问者

在C#中，许多设计模式已经被语言特性或框架内置支持，例如：

• 观察者模式通过事件(event)实现
• 迭代器模式通过IEnumerable和yield return实现
• 策略模式通过委托(delegate)实现

选择设计模式时应考虑项目的具体需求和复杂性，避免过度设计。