C#设计模式

在C#开发中，设计模式是解决常见问题的一种可复用的解决方案。以下是一些常用的C#设计模式：

一、创建型模式

1. 单例模式（Singleton）

   • 目的：确保一个类只有一个实例，并提供一个全局访问点。

   • 实现方式：通过私有化构造函数和静态字段来控制实例的创建。例如：

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

   • 适用场景：日志记录器、配置管理器等需要全局唯一实例的场景。

2. 工厂模式（Factory）

   • 目的：封装对象的创建逻辑，提供统一的接口来创建对象。
   • 实现方式：定义一个工厂类，通过工厂方法来创建对象。例如：

     public interface IProduct
     {
         void Show();
     }
     
     public class ConcreteProductA : IProduct
     {
         public void Show()
         {
             Console.WriteLine("Product A");
         }
     }
     
     public class ConcreteProductB : IProduct
     {
         public void Show()
         {
             Console.WriteLine("Product B");
         }
     }
     
     public class Factory
     {
         public IProduct CreateProduct(string type)
         {
             if (type == "A")
                 return new ConcreteProductA();
             else if (type == "B")
                 return new ConcreteProductB();
             return null;
         }
     }
     

   • 适用场景：当需要根据不同的条件创建不同类型的对象时。

3. 抽象工厂模式（Abstract Factory）

   • 目的：创建一组相关或依赖的对象，而无需指定它们的具体类。
   • 实现方式：定义一个抽象工厂接口和多个具体工厂类。例如：

     public interface IProductA
     {
         void Show();
     }
     
     public interface IProductB
     {
         void Show();
     }
     
     public class ConcreteProductA1 : IProductA
     {
         public void Show()
         {
             Console.WriteLine("Product A1");
         }
     }
     
     public class ConcreteProductB1 : IProductB
     {
         public void Show()
         {
             Console.WriteLine("Product B1");
         }
     }
     
     public class ConcreteProductA2 : IProductA
     {
         public void Show()
         {
             Console.WriteLine("Product A2");
         }
     }
     
     public class ConcreteProductB2 : IProductB
     {
         public void Show()
         {
             Console.WriteLine("Product B2");
         }
     }
     
     public interface IFactory
     {
         IProductA CreateProductA();
         IProductB CreateProductB();
     }
     
     public class ConcreteFactory1 : IFactory
     {
         public IProductA CreateProductA()
         {
             return new ConcreteProductA1();
         }
     
         public IProductB CreateProductB()
         {
             return new ConcreteProductB1();
         }
     }
     
     public class ConcreteFactory2 : IFactory
     {
         public IProductA CreateProductA()
         {
             return new ConcreteProductA2();
         }
     
         public IProductB CreateProductB()
         {
             return new ConcreteProductB2();
         }
     }
     

   • 适用场景：当需要创建一系列相关的产品对象时。

4. 建造者模式（Builder）

   • 目的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
   • 实现方式：定义一个建造者接口和多个具体建造者类。例如：

     public class Product
     {
         private List<string> parts = new List<string>();
         public void Add(string part)
         {
             parts.Add(part);
         }
     
         public void Show()
         {
             foreach (string part in parts)
             {
                 Console.WriteLine(part);
             }
         }
     }
     
     public interface IBuilder
     {
         void BuildPartA();
         void BuildPartB();
         Product GetResult();
     }
     
     public class ConcreteBuilder : IBuilder
     {
         private Product product = new Product();
     
         public void BuildPartA()
         {
             product.Add("PartA");
         }
     
         public void BuildPartB()
         {
             product.Add("PartB");
         }
     
         public Product GetResult()
         {
             return product;
         }
     }
     
     public class Director
     {
         private IBuilder builder;
     
         public Director(IBuilder builder)
         {
             this.builder = builder;
         }
     
         public void Construct()
         {
             builder.BuildPartA();
             builder.BuildPartB();
         }
     }
     

   • 适用场景：当需要构建一个复杂的对象时。

5. 原型模式（Prototype）

   • 目的：通过复制现有的实例来创建新的实例，而不是通过新建实例。
   • 实现方式：定义一个原型接口，实现克隆方法。例如：

     public interface IPrototype
     {
         IPrototype Clone();
     }
     
     public class ConcretePrototype : IPrototype
     {
         private string field;
     
         public ConcretePrototype(string field)
         {
             this.field = field;
         }
     
         public IPrototype Clone()
         {
             return (IPrototype)this.MemberwiseClone();
         }
     
         public void Show()
         {
             Console.WriteLine(field);
         }
     }
     

   • 适用场景：当需要创建大量相似的对象时。

二、结构型模式

1. 适配器模式（Adapter）
   • 目的：将一个类的接口转换成客户端所期望的另一种接口。
   • 实现方式：定义一个适配器类，实现客户端期望的接口，并在内部封装被适配的类。例如：

     public interface ITarget
     {
         void Request();
     }
     
     public class Adaptee
     {
         public void SpecificRequest()
         {
             Console.WriteLine("Adaptee SpecificRequest");
         }
     }
     
     public class Adapter : ITarget
     {
         private Adaptee adaptee;
     
         public Adapter()
         {
             adaptee = new Adaptee();
         }
     
         public void Request()
         {
             adaptee.SpecificRequest();
         }
     }
     

   • 适用场景：当需要使用一个不符合接口要求的类时。
2. 装饰器模式（Decorator）
   • 目的：动态地给一个对象添加额外的功能。
   • 实现方式：定义一个装饰器类，继承被装饰的类，并在内部封装被装饰的对象。例如：

     public interface IComponent
     {
         void Operation();
     }
     
     public class ConcreteComponent : IComponent
     {
         public void Operation()
         {
             Console.WriteLine("ConcreteComponent Operation");
         }
     }
     
     public abstract class Decorator : IComponent
     {
         protected IComponent component;
     
         public Decorator(IComponent component)
         {
             this.component = component;
         }
     
         public virtual void Operation()
         {
             component.Operation();
         }
     }
     
     public class ConcreteDecoratorA : Decorator
     {
         public ConcreteDecoratorA(IComponent component) : base(component) { }
     
         public override void Operation()
         {
             base.Operation();
             AddedBehavior();
         }
     
         private void AddedBehavior()
         {
             Console.WriteLine("ConcreteDecoratorA AddedBehavior");
         }
     }
     
     public class ConcreteDecoratorB : Decorator
     {
         public ConcreteDecoratorB(IComponent component) : base(component) { }
     
         public override void Operation()
         {
             base.Operation();
             AddedBehavior();
         }
     
         private void AddedBehavior()
         {
             Console.WriteLine("ConcreteDecoratorB AddedBehavior");
         }
     }
     

   • 适用场景：当需要动态地给对象添加功能时。
3. 代理模式（Proxy）
   • 目的：为其他对象提供一种代理以控制对这个对象的访问。
   • 实现方式：定义一个代理类，实现与被代理类相同的接口，并在内部封装被代理的对象。例如：

     public interface ISubject
     {
         void Request();
     }
     
     public class RealSubject : ISubject
     {
         public void Request()
         {
             Console.WriteLine("RealSubject Request");
         }
     }
     
     public class Proxy : ISubject
     {
         private RealSubject realSubject;
     
         public void Request()
         {
             if (realSubject == null)
             {
                 realSubject = new RealSubject();
             }
             PreRequest();
             realSubject.Request();
             PostRequest();
         }
     
         private void PreRequest()
         {
             Console.WriteLine("Proxy PreRequest");
         }
     
         private void PostRequest()
         {
             Console.WriteLine("Proxy PostRequest");
         }
     }
     

   • 适用场景：当需要控制对对象的访问时。
4. 外观模式（Facade）
   • 目的：为复杂的子系统提供一个简单的接口。
   • 实现方式：定义一个外观类，封装子系统的复杂逻辑。例如：

     public class SubSystemA
     {
         public void OperationA()
         {
             Console.WriteLine("SubSystemA OperationA");
         }