不参与网站建设的弊端安装百度

在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");}