西安网站建设设计北京外包seo公司

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