每个 C# 开发人员都应该掌握的 5 种强大的设计模式

郑子铭

发布于 2025-02-20 13:02:03

7500

代码可运行

文章被收录于专栏：DotNet NB && CloudNativeDotNet NB && CloudNative

运行总次数：0

代码可运行

想象一下你正在建造一栋房子。你是更愿意使用来自专业建筑师那些经过实践检验的蓝图呢，还是从头开始绘制所有的设计图呢？软件开发也是同样的道理！设计模式是针对常见问题的经实践验证的解决方案，它们提供了清晰的蓝图，能让你的代码更高效、更可复用且更易于维护。

在本文中，我们将深入探讨C#开发人员必须了解的五种设计模式。无论你是初学者还是经验丰富的专业人员，这些模式都将帮助你编写出更简洁、更灵活且更健壮的代码。此外，我们还会穿插一些专业提示，为你的开发技能助力！

单例模式：独一无二的力量它是什么？单例模式确保在你的应用程序中一个类只有一个实例，并提供一个全局访问点来访问该实例。可以把它想象成看门人——只有一个看门人，系统中的每个人都依赖这同一个实例。

为什么要使用它？当你需要管理共享资源时，比如日志记录、配置设置或者数据库连接，就会用到单例模式。如果存在多个实例，可能会导致不一致、资源浪费或者运行速度变慢等问题。

它是如何工作的？

创建一个私有静态变量来保存实例。
类有一个私有构造函数，以防止外部实例化。
通过一个公共方法返回该实例。

示例：

public class Singleton
{
    private static readonly Singleton _instance = new Singleton();
    
    private Singleton() {}  // 私有构造函数，确保只有单个实例。

    public static Singleton Instance => _instance;

    public void ShowMessage() => Console.WriteLine("单例实例处于活动状态！");
}

专业提示：线程安全很重要！：在多线程环境中使用单例模式时，务必处理好线程安全问题，以避免创建多个实例。可使用诸如延迟初始化或双重检查锁定之类的技术。使用案例：全局日志系统、配置管理器以及线程池。

工厂模式：为你的对象打造的工厂它是什么？工厂模式旨在将创建对象的任务委托给一个工厂类，这样你的代码就无需知道它正在创建的确切类了。这就好比是工厂的装配线，它会根据某些条件在恰当的时间产出正确的对象。

为什么要使用它？如果你的对象需要复杂的初始化过程，或者它们的类型取决于运行时的条件，那么工厂模式就提供了一种简洁且可复用的创建对象的方式。

它是如何工作的？

为你的产品定义一个通用接口。
工厂类决定要创建哪个具体的对象。
客户端只需与工厂进行交互，无需担心对象的具体类。

示例：

public abstract class Product
{
    public abstract void DoWork();
}

public class ProductA : Product
{
    public override void DoWork() => Console.WriteLine("产品A正在工作！");
}

public class ProductB : Product
{
    public override void DoWork() => Console.WriteLine("产品B正在工作！");
}

public class ProductFactory
{
    public static Product CreateProduct(string productType)
    {
        return productType switch
        {
            "A" => new ProductA(),
            "B" => new ProductB(),
            _ => throw new ArgumentException("无效的产品类型")
        };
    }
}

专业提示：解耦创建逻辑：工厂模式非常适合隐藏对象创建的复杂性，并提供一个更灵活的系统。当你的对象创建过程涉及大量变化或配置时，就可以使用它。使用案例：

基于用户输入或配置文件进行动态对象创建。
复杂的初始化过程，比如设置数据库连接或者不同类型的文档解析器。

观察者模式：保持系统同步它是什么？观察者模式非常适用于事件驱动型系统。它允许一个对象（主体）在其状态发生变化时通知多个其他对象（观察者）。可以把它想象成社交媒体的通知——当一个用户发布更新内容时，所有订阅的人都会收到通知。

为什么要使用它？如果在一个组件发生变化时，你需要更新系统的各个部分（且不进行紧耦合），那么观察者模式就很有用了。它非常适合管理实时更新、事件处理以及保持各部分同步。

它是如何工作的？

主体维护一个观察者列表。
观察者订阅主体以接收更新内容。
当主体的状态发生变化时，它会通知所有的观察者。

示例：

public interface IObserver
{
    void Update(string message);
}

public class ConcreteObserver : IObserver
{
    public void Update(string message) => Console.WriteLine($"观察者收到：{message}");
}

public class Subject
{
    private readonly 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) => _observers.ForEach(observer => observer.Update(message));
}

装饰器模式：动态添加功能它是什么？装饰器模式允许你在运行时动态地向一个对象添加行为，而无需改变该对象所属的类。想象一下你正在组装一个定制蛋糕——你先从一个基础（简单的蛋糕）开始，然后不断添加层次（装饰器），比如糖霜、糖粒和配料等。

为什么要使用它？当你需要以一种灵活且可复用的方式向对象添加新功能时，装饰器模式是理想之选。相比于为每种可能的功能组合创建子类，装饰器允许你在运行时对功能进行混合搭配。

它是如何工作的？

一个基类定义通用功能。
装饰器类在不改变基类的情况下添加新功能。
你可以将多个装饰器相互叠加使用。

示例：

public abstract class Coffee
{
    public abstract double Cost();
    public abstract string Description();
}

public class SimpleCoffee : Coffee
{
    public override double Cost() => 1.0;
    public override string Description() => "简单咖啡";
}

public class MilkDecorator : Coffee
{
    private readonly Coffee _coffee;
    
    public MilkDecorator(Coffee coffee) => _coffee = coffee;

    public override double Cost() => _coffee.Cost() + 0.5;
    public override string Description() => _coffee.Description() + " + 牛奶";
}

专业提示：用于扩展性：当你需要添加诸如日志记录、验证或者安全等功能，又不想修改原始对象时，装饰器模式就很棒。它能让你以一种简洁且模块化的方式扩展功能。使用案例：

用附加行为修改用户界面元素（比如给按钮添加边框、阴影或者事件处理功能）。
为对象赋予新职责进行包装，比如日志记录或者缓存功能。

策略模式：选择你的方法它是什么？策略模式对于动态行为选择来说是一个变革性的模式。它定义了一系列算法，将每个算法都封装起来，并使其可以相互替换。你可以根据条件在运行时选择合适的策略。

为什么要使用它？与其在你的代码中到处编写if-else或者switch-case语句，策略模式将每种行为都封装为一个对象。这会使代码更简洁、更灵活，更易于维护和扩展。

它是如何工作的？

为策略定义一个接口。
实现具体的策略，将每种特定行为都封装起来。
上下文类使用一种策略，并且可以在运行时对其进行更改。

示例：

public interface IStrategy
{
    void Execute();
}

public class StrategyA : IStrategy
{
    public void Execute() => Console.WriteLine("执行策略A");
}

public class StrategyB : IStrategy
{
    public void Execute() => Console.WriteLine("执行策略B");
}

public class Context
{
    private IStrategy _strategy;

    public Context(IStrategy strategy) => _strategy = strategy;

    public void SetStrategy(IStrategy strategy) => _strategy = strategy;
    public void ExecuteStrategy() => _strategy.Execute();
}

专业提示：解耦算法：当你有可互换的算法或行为时，使用策略模式。这使得你能够轻松地替换它们，避免混乱的条件逻辑。使用案例：