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