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