C#学习第23天：面向对象设计模式

什么是设计模式？

---

• 定义：设计模式是软件开发中反复出现的特定问题的解决方案。它们提供了问题的抽象描述和解决方案。
• 目的：通过提供成熟的解决方案，设计模式可以加快开发速度并提高代码质量。

常见的设计模式 

---

设计模式通常分为三大类：创建型模式、结构型模式和行为型模式。

创建型模式

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);// 执行策略Acontext.ExecuteStrategy();// 切换到策略Bcontext.SetStrategy(strategyB);// 执行策略Bcontext.ExecuteStrategy();}
}

使用场景

---

代码重用与扩展：

• 设计模式提供了可重用的代码解决方案，可方便地扩展功能。

降低耦合度：

• 通过将行为或功能解耦并封装在独立的类中，设计模式降低了系统的耦合性。

提高可维护性：

• 清晰的设计模式使得代码更易于理解和维护。

---

通过理解和使用设计模式，您可以更有效地解决复杂的软件设计问题，提高代码的质量和可维护性。如果有任何问题或者需要进一步指导，请随时告诉我！