什么是设计模式？
- 定义：设计模式是软件开发中反复出现的特定问题的解决方案。它们提供了问题的抽象描述和解决方案。
- 目的：通过提供成熟的解决方案，设计模式可以加快开发速度并提高代码质量。
常见的设计模式
设计模式通常分为三大类：创建型模式、结构型模式和行为型模式。
创建型模式
1.单例模式（Singleton Pattern）
- 目的：确保一个类只有一个实例，并提供一个全局访问点。
- 应用：用于管理共享资源，如配置类、日志记录类等。
public class Singleton
{
private static Singleton instance = null;
private static readonly object padlock = new object();
private Singleton() { }
public static Singleton Instance
{
get
{
lock (padlock)
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}
}
// padlock 是一个线程同步锁对象
// 1. 用于确保在多线程环境下,同一时间只有一个线程可以访问 Instance 属性
// 2. 防止多个线程同时创建单例实例,避免产生多个实例
// 3. lock(padlock) 会在代码块执行期间锁定 padlock 对象
// 4. 其他试图访问这个被锁定代码块的线程将被阻塞,直到锁被释放
// 5. readonly 确保 padlock 对象在运行时不会被修改,增加了线程安全性
// 单例模式示例调用代码
public class SingletonDemo
{
public static void Run()
{
// 获取单例实例
Singleton instance1 = Singleton.Instance;
Singleton instance2 = Singleton.Instance;
// 验证是否是同一个实例
bool isSameInstance = ReferenceEquals(instance1, instance2);
Console.WriteLine($"instance1 和 instance2 是否是同一个实例: {isSameInstance}");
// 多线程测试
Parallel.For(0, 10, i =>
{
Singleton instance = Singleton.Instance;
Console.WriteLine($"线程 {i} 获取的实例: {instance.GetHashCode()}");
});
}
}2.工厂模式（Factory Pattern）
- 目的：定义一个用于创建对象的接口，让子类决定实例化哪个类。
- 应用：适合用于需要灵活创建对象的场景，隐藏复杂的创建逻辑。
public interface IProduct
{
void Use();
}
public class ConcreteProductA : IProduct
{
public void Use() => Console.WriteLine("Using Product A");
}
public class ConcreteProductB : IProduct
{
public void Use() => Console.WriteLine("Using Product B");
}
public class ProductFactory
{
public IProduct CreateProduct(string type)
{
if (type == "A")
return new ConcreteProductA();
if (type == "B")
return new ConcreteProductB();
// 可以扩展其他产品
throw new ArgumentException("Invalid type");
}
}结构型模式
1.适配器模式（Adapter Pattern）
- 目的：将一个类的接口转换为客户期望的另一个接口，使得原本不兼容的类可以一起工作。
- 应用：用于集成第三方库或遗留系统。
public interface ITarget
{
void Request();
}
public class Adaptee
{
public void SpecificRequest() => Console.WriteLine("Specific Request");
}
public class Adapter : ITarget
{
private Adaptee adaptee = new Adaptee();
public void Request() => adaptee.SpecificRequest();
}
2.装饰器模式（Decorator Pattern）
- 目的：动态地给对象添加职责。
- 应用：用于需要动态地添加功能的场合，而不影响其他对象的使用。
public abstract class Component
{
public abstract void Operation();
}
public class ConcreteComponent : Component
{
public override void Operation() => Console.WriteLine("ConcreteComponent Operation");
}
public abstract class Decorator : Component
{
protected Component component;
public void SetComponent(Component component)
{
this.component = component;
}
public override void Operation()
{
if (component != null)
{
component.Operation();
}
}
}
public class ConcreteDecorator : Decorator
{
public override void Operation()
{
base.Operation();
AddedBehavior();
}
void AddedBehavior()
{
Console.WriteLine("ConcreteDecorator Added Behavior");
}
}
// 装饰器模式示例调用代码
public class DecoratorDemo
{
public static void Run()
{
// 创建具体组件
var component = new ConcreteComponent();
// 创建装饰器
var decorator = new ConcreteDecorator();
// 设置装饰器的组件
decorator.SetComponent(component);
// 调用装饰后的操作
decorator.Operation();
// 输出:
// ConcreteComponent Operation
// ConcreteDecorator Added Behavior
}
}
行为型模式
1.观察者模式（Observer Pattern）
- 目的：定义对象间的一对多依赖，当一个对象改变状态时，所有依赖的对象都会被通知并自动更新。
- 应用：适用于事件驱动的编程中，如GUI控件事件。
public interface IObserver
{
void Update(string message);
}
public class ConcreteObserver : IObserver
{
private string name;
public ConcreteObserver(string name)
{
this.name = name;
}
public void Update(string message) => Console.WriteLine($"{name} 收到消息: {message}");
}
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(string message)
{
foreach (var observer in observers)
{
observer.Update(message);
}
}
}
// 示例调用代码
public class ObserverDemo
{
public static void Run()
{
// 创建主题
var subject = new Subject();
// 创建观察者
var observer1 = new ConcreteObserver("观察者1");
var observer2 = new ConcreteObserver("观察者2");
var observer3 = new ConcreteObserver("观察者3");
// 注册观察者
subject.Attach(observer1);
subject.Attach(observer2);
subject.Attach(observer3);
// 发送通知
subject.Notify("系统更新完成");
// 移除一个观察者
subject.Detach(observer2);
// 再次发送通知
subject.Notify("新消息到达");
}
}2.策略模式（Strategy Pattern）
- 目的：定义一系列算法，将每个算法封装起来，并使它们可以互换。
- 应用：用于消除条件语句，并在运行时更改算法。
public interface IStrategy
{
void Execute(); // 执行策略
}
public class ConcreteStrategyA : IStrategy
{
public void Execute() => Console.WriteLine("执行策略A");
}
public class ConcreteStrategyB : IStrategy
{
public void Execute() => Console.WriteLine("执行策略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();
}
// 策略模式示例调用代码
public class StrategyDemo
{
public static void Run()
{
// 创建具体策略对象
var strategyA = new ConcreteStrategyA();
var strategyB = new ConcreteStrategyB();
// 创建上下文并设置初始策略
var context = new Context(strategyA);
// 执行策略A
context.ExecuteStrategy();
// 切换到策略B
context.SetStrategy(strategyB);
// 执行策略B
context.ExecuteStrategy();
}
}使用场景
代码重用与扩展：
- 设计模式提供了可重用的代码解决方案，可方便地扩展功能。
降低耦合度：
- 通过将行为或功能解耦并封装在独立的类中，设计模式降低了系统的耦合性。
提高可维护性：
- 清晰的设计模式使得代码更易于理解和维护。
通过理解和使用设计模式，您可以更有效地解决复杂的软件设计问题，提高代码的质量和可维护性。如果有任何问题或者需要进一步指导，请随时告诉我！
