C# 中常见的设计模式附带代码案例

设计模式是一套被广泛应用于软件设计的最佳实践，它们可以帮助开发者解决特定的问题，提高代码的可重用性、可读性和可维护性。本文将介绍 C#
中常见的几种设计模式，并提供相应的示例代码。

* 工厂模式

工厂模式是一种创建型设计模式，它提供了一种将对象的创建过程与使用过程分离的方式。它通过定义一个工厂类，使得客户端代码可以从工厂类中获取所需的对象，而无需知道对象的具体创建过程。

以下是工厂模式的一个示例：
public interface IProduct { void DoSomething(); } public class ProductA :
IProduct { public void DoSomething() { Console.WriteLine("ProductA does
something."); } } public class ProductB : IProduct { public void DoSomething() {
Console.WriteLine("ProductB does something."); } } public class ProductFactory
{ public IProduct CreateProduct(string type) { switch (type) { case "A": return
new ProductA(); case "B": return new ProductB(); default: throw new
ArgumentException("Invalid product type"); } } } class Program { static void
Main(string[] args) { ProductFactory factory = new ProductFactory(); IProduct
productA= factory.CreateProduct("A"); IProduct productB = factory.CreateProduct(
"B"); productA.DoSomething(); productB.DoSomething(); Console.ReadKey(); } }
在上面的示例中，我们定义了 IProduct 接口和两个实现类 ProductA 和 ProductB。然后，我们定义了一个工厂类
ProductFactory，它可以根据客户端代码传入的参数创建不同的产品对象。

在客户端代码中，我们实例化了 ProductFactory
并通过它创建了两个不同的产品对象。这种方式可以使得客户端代码不需要知道对象的具体创建过程，从而提高了代码的可重用性和可维护性。

* 单例模式
单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供了全局访问该实例的方式。

以下是单例模式的一个示例：
public class Singleton { private static Singleton instance; private Singleton()
{ } public static Singleton Instance { get { if (instance == null) { instance =
new Singleton(); } return instance; } } public void DoSomething() { Console.
WriteLine("Singleton does something."); } } class Program { static void Main(
string[] args) { Singleton singleton = Singleton.Instance; singleton.DoSomething
(); Console.ReadKey(); } }
在上面的示例中，我们定义了一个 Singleton 类，并通过将构造函数私有化来防止外部直接实例化它。然后，我们定义了一个静态字段
instance，用来保存 Singleton 类的唯一实例。我们还定义了一个静态属性 Instance，通过它来获取 Singleton 类的唯一实例。

在客户端代码中，我们通过 Singleton.Instance 获取 Singleton 类的唯一实例，并调用它的 DoSomething 方法。由于
Singleton 类只有一个实例，因此多次调用 Singleton.Instance 得到的都是同一个实例。

* 观察者模式
观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，使得多个观察者对象可以同时监听某个主题对象的状态变化。

以下是观察者模式的一个示例：
public interface IObserver { void Update(string message); } public interface
ISubject { void RegisterObserver(IObserver observer); void RemoveObserver(
IObserver observer); void NotifyObservers(string message); } public class
Subject : ISubject { private List<IObserver> observers = new List<IObserver>();
public void RegisterObserver(IObserver observer) { observers.Add(observer); }
public void RemoveObserver(IObserver observer) { observers.Remove(observer); }
public void NotifyObservers(string message) { foreach (IObserver observer in
observers) { observer.Update(message); } } } public class Observer : IObserver {
public void Update(string message) { Console.WriteLine($"Observer received
message:{message}"); } } class Program { static void Main(string[] args) {
Subject subject = new Subject(); Observer observer1 = new Observer(); Observer
observer2= new Observer(); subject.RegisterObserver(observer1); subject.
RegisterObserver(observer2); subject.NotifyObservers("Hello, observers!");
subject.RemoveObserver(observer2); subject.NotifyObservers("Hello again,
observers!"); Console.ReadKey(); } }
在上面的示例中，我们定义了 IObserver 和 ISubject 接口，分别表示观察者和主题对象。然后，我们实现了 Subject 类，它实现了
ISubject 接口，并提供了注册观察者、移除观察者和通知观察者的方法。我们还实现了 Observer 类，它实现了 IObserver 接口，并在
Update 方法中打印出接收到的消息。
在客户端代码中，我们创建了一个 Subject 对象和两个 Observer 对象，并通过 RegisterObserver 方法将这两个观察者对象注册到
Subject 对象上。然后，我们调用 NotifyObservers 方法，将消息发送给所有注册的观察者对象。最后，我们通过 RemoveObserver
方法移除了一个观察者对象，并再次调用 NotifyObservers 方法发送消息给剩下的观察者对象。

* 策略模式
策略模式是一种行为型设计模式，它定义了一系列算法，将每个算法都封装起来，并且使它们之间可以互换。

以下是策略模式的一个示例：
public interface IStrategy { void Execute(); } public class StrategyA :
IStrategy { public void Execute() { Console.WriteLine("Strategy A is executed.")
; } } public class StrategyB : IStrategy { public void Execute() { Console.
WriteLine("Strategy B is executed."); } } 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(string[] args) { IStrategy strategyA = new StrategyA(
); IStrategy strategyB = new StrategyB(); Context context = new Context(
strategyA); context.ExecuteStrategy(); context.SetStrategy(strategyB); context.
ExecuteStrategy(); Console.ReadKey(); } }
在上面的示例中，我们定义了 IStrategy 接口，表示一个算法的接口。然后，我们实现了两个具体的策略类 StrategyA 和
StrategyB，它们分别实现了 IStrategy 接口。最后，我们定义了 Context 类，它包含一个 IStrategy 类型的字段和一个
ExecuteStrategy 方法，通过它来执行当前策略对象的算法。Context 类还提供了一个 SetStrategy 方法，用于在运行时切换策略对象。

在客户端代码中，我们创建了一个 Context 对象，并将 StrategyA 对象作为它的构造参数。然后，我们调用 ExecuteStrategy
方法，执行 StrategyA 的算法。接着，我们调用 SetStrategy 方法，将策略对象切换为 StrategyB，再次调用
ExecuteStrategy 方法，执行 StrategyB 的算法。

以上是 C# 中几种常见的设计模式以及相应的示例代码。

• « 上一篇：大数据是干什么的？
• » 下一篇：训练一个ChatGPT需要多少数据？