目录
引言
1. 单例模式 (Singleton Pattern)
2. 工厂模式 (Factory Pattern)
3. 观察者模式 (Observer Pattern)
4. 策略模式 (Strategy Pattern)
5. 装饰器模式 (Decorator Pattern)
总结
引言
在软件开发过程中，设计模式是一个重要的工具，它为常见问题提供了解决方案的模板。了解和应用这些模式可以帮助开发者提升代码的可维护性、可扩展性和可读性。本文将深入探讨C#开发中常用的设计模式，包括它们的定义、使用场景、核心要点及示例代码，帮助你在实际项目中更好地应用这些模式。
1. 单例模式 (Singleton Pattern)
定义：确保一个类只有一个实例，并提供一个全局访问点。
使用场景：
- 需要控制实例数目，节约系统资源。
- 需要一个共享的全局访问点。
核心/关键点：
- 构造函数私有化。
- 提供一个静态方法或属性来获取单例对象。
- 确保线程安全。
代码示例：
public sealed class Singleton
{
// 静态变量用于保存单例实例
private static Singleton instance = null;
// 用于线程安全的锁对象
private static readonly object padlock = new object();
// 私有化构造函数，防止外部实例化
private Singleton()
{
}
// 公共静态方法，用于获取单例实例
public static Singleton Instance
{
get
{
// 双重检查锁定，确保线程安全
if (instance == null)
{
lock (padlock)
{
if (instance == null)
{
instance = new Singleton();
}
}
}
return instance;
}
}
// 示例方法
public void DoSomething()
{
Console.WriteLine("Singleton instance is doing something.");
}
}
// 使用单例模式
class Program
{
static void Main()
{
Singleton singleton = Singleton.Instance;
singleton.DoSomething();
}
}
2. 工厂模式 (Factory Pattern)
定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
使用场景：
- 创建对象需要复杂的逻辑。
- 需要创建一系列相关或依赖的对象。
核心/关键点：
- 提供一个创建对象的接口。
- 由子类实现具体的对象创建逻辑。
代码示例：
// 产品接口
public interface IProduct
{
void Display();
}
// 具体产品A
public class ProductA : IProduct
{
public void Display()
{
Console.WriteLine("Product A");
}
}
// 具体产品B
public class ProductB : IProduct
{
public void Display()
{
Console.WriteLine("Product B");
}
}
// 工厂类
public abstract class Factory
{
public abstract IProduct CreateProduct();
}
// 具体工厂A
public class FactoryA : Factory
{
public override IProduct CreateProduct()
{
return new ProductA();
}
}
// 具体工厂B
public class FactoryB : Factory
{
public override IProduct CreateProduct()
{
return new ProductB();
}
}
// 使用工厂模式
class Program
{
static void Main()
{
Factory factoryA = new FactoryA();
IProduct productA = factoryA.CreateProduct();
productA.Display();
Factory factoryB = new FactoryB();
IProduct productB = factoryB.CreateProduct();
productB.Display();
}
}
3. 观察者模式 (Observer Pattern)
定义：定义对象间一对多的依赖关系，当一个对象改变状态时，所有依赖者都会收到通知并自动更新。
使用场景：
- 一个对象的改变需要通知其他对象，但它不知道具体有多少对象需要被通知。
- 一个对象需要通知其它对象，但两者的耦合度要低。
核心/关键点：
- 需要一个主题对象和多个观察者对象。
- 主题对象维护观察者列表，并通知观察者。
代码示例：
// 观察者接口
public interface IObserver
{
void Update();
}
// 具体观察者A
public class ObserverA : IObserver
{
public void Update()
{
Console.WriteLine("Observer A notified.");
}
}
// 具体观察者B
public class ObserverB : IObserver
{
public void Update()
{
Console.WriteLine("Observer B notified.");
}
}
// 主题接口
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 (IObserver observer in observers)
{
observer.Update();
}
}
public void SomeBusinessLogic()
{
// 业务逻辑
Console.WriteLine("Subject did something.");
// 通知观察者
Notify();
}
}
// 使用观察者模式
class Program
{
static void Main()
{
Subject subject = new Subject();
ObserverA observerA = new ObserverA();
ObserverB observerB = new ObserverB();
subject.Attach(observerA);
subject.Attach(observerB);
subject.SomeBusinessLogic();
subject.Detach(observerA);
subject.SomeBusinessLogic();
}
}
4. 策略模式 (Strategy Pattern)
定义：定义一系列算法，把它们一个个封装起来，并且使它们可互换。
使用场景：
- 需要在不同情况下使用不同的算法。
- 避免使用多重条件判断语句。
核心/关键点：
- 定义一系列可互换的策略。
- 上下文类使用策略接口进行操作。
代码示例：
// 策略接口
public interface IStrategy
{
void Execute();
}
// 具体策略A
public class StrategyA : IStrategy
{
public void Execute()
{
Console.WriteLine("Executing Strategy A");
}
}
// 具体策略B
public class StrategyB : IStrategy
{
public void Execute()
{
Console.WriteLine("Executing Strategy B");
}
}
// 上下文类
public class Context
{
private IStrategy strategy;
public Context(IStrategy strategy)
{
this.strategy = strategy;
}
public void SetStrategy(IStrategy strategy)
{
this.strategy = strategy;
}
public void ExecuteStrategy()
{
strategy.Execute();
}
}
// 使用策略模式
class Program
{
static void Main()
{
Context context = new Context(new StrategyA());
context.ExecuteStrategy();
context.SetStrategy(new StrategyB());
context.ExecuteStrategy();
}
}
5. 装饰器模式 (Decorator Pattern)
定义：动态地给对象添加新的职责功能。
使用场景：
- 需要在不改变现有类的情况下给对象添加功能。
- 需要动态地给对象添加或撤销功能。
核心/关键点：
- 通过组合而非继承来扩展对象功能。
- 装饰器类包含一个组件对象的引用，并实现组件接口。
代码示例：
// 组件接口
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();
}
}
// 具体装饰器A
public class ConcreteDecoratorA : Decorator
{
public ConcreteDecoratorA(IComponent component) : base(component)
{
}
public override void Operation()
{
base.Operation();
AddedBehavior();
}
void AddedBehavior()
{
Console.WriteLine("ConcreteDecoratorA Added Behavior");
}
}
// 具体装饰器B
public class ConcreteDecoratorB : Decorator
{
public ConcreteDecoratorB(IComponent component) : base(component)
{
}
public override void Operation()
{
base.Operation();
AddedBehavior();
}
void AddedBehavior()
{
Console.WriteLine("ConcreteDecoratorB Added Behavior");
}
}
// 使用装饰器模式
class Program
{
static void Main()
{
IComponent component = new ConcreteComponent();
IComponent decoratorA = new ConcreteDecoratorA(component);
IComponent decoratorB = new ConcreteDecoratorB(decoratorA);
decoratorB.Operation();
}
}
总结
通过本文的学习，我们了解了几种常用的C#设计模式，包括单例模式、工厂模式、观察者模式、策略模式和装饰器模式。每种模式都有其独特的应用场景和实现方法。在实际开发中，灵活运用这些设计模式能帮助我们解决复杂的设计问题，提高代码质量。希望本文能为你在设计和开发过程中提供有益的指导，让你的代码更简洁高效。