欢迎来到 C# 设计模式 的第六章！在这一章中，我们将深入探讨 装饰器模式（Decorator Pattern）。装饰器模式是一种结构型设计模式，它允许你在不修改原有类的情况下，动态地为对象添加新的功能或行为。想象一下，你有一杯普通的咖啡，但你想让它变得更特别——你可以加糖、加奶、甚至撒上一些肉桂粉。每次添加新东西时，咖啡的味道和外观都会发生变化，但它的核心仍然是咖啡。装饰器模式正是这样一种模式，它让你可以在不改变原始对象的情况下，通过“装饰”来增强它的功能。

第一节：什么是装饰器模式？

1. 概念：

装饰器模式的核心思想是：动态地将责任附加到对象上，而不需要修改对象的原有代码。换句话说，装饰器模式允许你在运行时为对象添加新的功能或行为，而不必创建新的子类。这使得代码更加灵活和可扩展，因为你可以在不修改现有代码的情况下，轻松地为对象添加新的特性。

幽默小贴士：

装饰器模式就像是编程世界里的“魔法调料”，你可以通过它为任何菜肴添加不同的风味，而不需要重新烹饪整个菜品。就像《爱丽丝梦游仙境》中的疯狂茶会一样，你可以通过装饰器模式为每一杯茶添加不同的配料，让每一杯都变得独一无二！ 🍵

2. 为什么需要装饰器模式？
  • 动态添加功能：有时候，你可能希望在运行时为对象添加新的功能，而不是在编译时通过继承来实现。装饰器模式允许你在不修改原有类的情况下，动态地为对象添加新的行为。
  • 避免类爆炸：如果你使用继承来为每个组合的功能创建一个新的子类，那么类的数量将会迅速增加，导致代码难以维护。装饰器模式通过组合的方式解决了这个问题，使得代码更加简洁和可维护。
  • 支持多态性：装饰器模式允许你在运行时动态地选择要添加的功能，而不需要硬编码具体的类名。你可以根据不同的条件为对象添加不同的装饰器，从而使代码更加灵活。

第二节：真实案例

1. 咖啡店的饮品系统：

想象一下，你是一家咖啡店的老板，顾客可以选择不同的饮品，并且可以根据自己的喜好添加各种配料，如糖、奶、肉桂粉等。为了实现这个功能，你可以使用装饰器模式来动态地为每杯饮品添加不同的配料，而不需要为每种组合创建一个新的类。

幽默小贴士：

在咖啡店的饮品系统中，装饰器模式就像是“魔法调料瓶”，你可以通过它为每一杯咖啡添加不同的配料，让每一杯都变得独一无二。就像《爱丽丝梦游仙境》中的疯狂茶会一样，你可以通过装饰器模式为每一杯茶添加不同的配料，让每一杯都变得独一无二！ ☕

2. 图形用户界面（GUI）组件：

假设你在开发一个图形用户界面（GUI）应用程序，用户可以选择不同的控件（如按钮、文本框等），并且可以根据自己的需求为这些控件添加额外的功能，如边框、阴影、背景颜色等。为了实现这个功能，你可以使用装饰器模式来动态地为每个控件添加不同的装饰效果，而不需要为每种组合创建一个新的类。

幽默小贴士：

在 GUI 组件的例子中，装饰器模式就像是“魔法画笔”，你可以通过它为每个控件添加不同的装饰效果，让每一个控件都变得独一无二。就像《冰雪奇缘》中的艾莎女王一样，她可以通过魔法为每一个物体添加不同的装饰，让它们变得更加美丽！ ✨

第三节：实施方法

在 C# 中实现装饰器模式通常涉及以下几个类：

  1. IComponent 接口：这是你要装饰的对象的接口，定义了所有组件的公共行为。
  2. ConcreteComponent 类：这是实现了 IComponent 接口的具体组件类，代表你要装饰的对象。
  3. Decorator 类：这是装饰器类的基类，它也实现了 IComponent 接口，并持有一个对 IComponent 对象的引用。装饰器类负责为被装饰的对象添加新的功能。
  4. ConcreteDecoratorX 类：这是实现了 Decorator 类的具体装饰器类，每个具体装饰器类负责为被装饰的对象添加特定的功能。
  5. Client 类（客户端代码）：这是使用装饰器模式的客户端代码。它通过调用 IComponent 接口的方法来与被装饰的对象进行交互，而不需要知道具体的实现细节。

第四节：类之间的关系

1. 所需的类

在实现装饰器模式时，通常需要以下几个类：

  1. IComponent 接口：

    • 这是要装饰的对象的接口，定义了所有组件的公共行为。所有的具体组件类和装饰器类都必须实现这个接口。

  2. ConcreteComponent 类：

    • 这是实现了 IComponent 接口的具体组件类，代表你要装饰的对象。它提供了基本的功能，而装饰器类可以为其添加额外的功能。

  3. Decorator 类：

    • 这是装饰器类的基类，它也实现了 IComponent 接口，并持有一个对 IComponent 对象的引用。装饰器类负责为被装饰的对象添加新的功能。

  4. ConcreteDecoratorX 类：

    • 这是实现了 Decorator 类的具体装饰器类，每个具体装饰器类负责为被装饰的对象添加特定的功能。

  5. Client 类（客户端代码）：

    • 这是使用装饰器模式的客户端代码。它通过调用 IComponent 接口的方法来与被装饰的对象进行交互，而不需要知道具体的实现细节。
2. 类的详细说明
1. IComponent 接口
// 定义组件接口
public interface IComponent
{
    void Operation();
}
  • 作用：IComponent 接口是要装饰的对象的接口，定义了所有组件的公共行为。在这个例子中，我们定义了一个 Operation() 方法，用于执行某个操作。
  • 优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的组件或装饰器类。
2. ConcreteComponent 类
// 实现具体组件类
public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("我是具体的组件，我执行了基本的操作");
    }
}
  • 作用：ConcreteComponent 类是实现了 IComponent 接口的具体组件类，代表你要装饰的对象。它提供了基本的功能，而装饰器类可以为其添加额外的功能。
  • 优点：通过实现具体的 Operation() 方法，ConcreteComponent 类可以执行基本的操作，而不需要依赖其他类。
3. Decorator 类
// 定义装饰器类的基类
public abstract class Decorator : IComponent
{
    protected IComponent _component;

    public Decorator(IComponent component)
    {
        _component = component;
    }

    public virtual void Operation()
    {
        if (_component != null)
        {
            _component.Operation();
        }
    }
}
  • 作用：Decorator 类是装饰器类的基类，它也实现了 IComponent 接口，并持有一个对 IComponent 对象的引用。装饰器类负责为被装饰的对象添加新的功能。
  • 优点：通过继承 Decorator 类，具体装饰器类可以轻松地为被装饰的对象添加新的功能，而不需要重复编写相同的代码。
4. ConcreteDecoratorX 类
// 实现具体装饰器类 1
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        // 在执行原有操作之前添加新的功能
        Console.WriteLine("我是装饰器 A，在执行原有操作之前添加了一些功能");

        // 调用被装饰对象的 Operation() 方法
        base.Operation();

        // 在执行原有操作之后添加新的功能
        Console.WriteLine("我是装饰器 A，在执行原有操作之后添加了一些功能");
    }
}

// 实现具体装饰器类 2
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        // 在执行原有操作之前添加新的功能
        Console.WriteLine("我是装饰器 B，在执行原有操作之前添加了一些功能");

        // 调用被装饰对象的 Operation() 方法
        base.Operation();

        // 在执行原有操作之后添加新的功能
        Console.WriteLine("我是装饰器 B，在执行原有操作之后添加了一些功能");
    }
}
  • 作用：ConcreteDecoratorA 和 ConcreteDecoratorB 是实现了 Decorator 类的具体装饰器类，每个具体装饰器类负责为被装饰的对象添加特定的功能。它们可以通过重写 Operation() 方法，在执行原有操作之前或之后添加新的功能。
  • 优点：通过继承 Decorator 类，具体装饰器类可以轻松地为被装饰的对象添加新的功能，而不需要重复编写相同的代码。
5. Client 类（客户端代码）
class Program
{
    static void Main(string[] args)
    {
        // 创建具体的组件对象
        IComponent component = new ConcreteComponent();

        // 使用装饰器 A 包装组件对象
        IComponent decoratedComponentA = new ConcreteDecoratorA(component);

        // 使用装饰器 B 包装装饰器 A
        IComponent decoratedComponentB = new ConcreteDecoratorB(decoratedComponentA);

        // 调用装饰后的组件对象的 Operation() 方法
        decoratedComponentB.Operation();
    }
}
  • 作用：Client 类是使用装饰器模式的客户端代码。它通过调用 IComponent 接口的方法来与被装饰的对象进行交互，而不需要知道具体的实现细节。
  • 优点：通过装饰器模式，客户端代码可以轻松地为对象添加新的功能，而不需要修改现有的代码。
3. 类之间的关系

现在我们已经了解了所有需要的类，接下来让我们通过类图来展示这些类之间的关系。

类图示例：
+-------------------+
|     IComponent    |
+-------------------+
| + Operation()     |
+-------------------+
         ^
         |
+-------------------+       +---------------------------+
|  ConcreteComponent |      |      Decorator            |
+-------------------+       +---------------------------+
| + Operation()     |       | - _component: IComponent  |
+-------------------+       | + Operation()             |
         ^                  +---------------------------+ 
         |                        |
         |                        v
         |                  +---------------------------+
         |                  | ConcreteDecoratorA        |
         |                  +---------------------------+
         |                  | + Operation()             |
         |                  +---------------------------+
         |                        ^
         |                        |
         |                  +---------------------------+
         |                  | ConcreteDecoratorB        |
         |                  +---------------------------+
         |                  | + Operation()             |
         |                  +---------------------------+
         |
+-------------------+
|       Client      |
+-------------------+
| + Main(): void    |
+-------------------+
幽默小贴士：

类图就像是编程世界的“魔法配方”，它展示了各个类之间的组合方式。IComponent 是“基础食材”，定义了所有组件的公共行为。ConcreteComponent 是“具体食材”，提供了基本的功能。Decorator 是“魔法调料瓶”，它可以为任何食材添加不同的风味。ConcreteDecoratorA 和 ConcreteDecoratorB 是“具体调料”，它们分别为食材添加了不同的风味。Client 是“厨师”，它只需要按照配方组合食材和调料，就能做出美味的菜肴！ 🌟

第五节：程序执行与输出

让我们通过几个实际的代码示例来演示装饰器模式的使用。

示例 1：基本装饰器模式
using System;

// 定义组件接口
public interface IComponent
{
    void Operation();
}

// 实现具体组件类
public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("我是具体的组件，我执行了基本的操作");
    }
}

// 定义装饰器类的基类
public abstract class Decorator : IComponent
{
    protected IComponent _component;

    public Decorator(IComponent component)
    {
        _component = component;
    }

    public virtual void Operation()
    {
        if (_component != null)
        {
            _component.Operation();
        }
    }
}

// 实现具体装饰器类 1
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        Console.WriteLine("我是装饰器 A，在执行原有操作之前添加了一些功能");
        base.Operation();
        Console.WriteLine("我是装饰器 A，在执行原有操作之后添加了一些功能");
    }
}

// 实现具体装饰器类 2
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        Console.WriteLine("我是装饰器 B，在执行原有操作之前添加了一些功能");
        base.Operation();
        Console.WriteLine("我是装饰器 B，在执行原有操作之后添加了一些功能");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建具体的组件对象
        IComponent component = new ConcreteComponent();

        // 使用装饰器 A 包装组件对象
        IComponent decoratedComponentA = new ConcreteDecoratorA(component);

        // 使用装饰器 B 包装装饰器 A
        IComponent decoratedComponentB = new ConcreteDecoratorB(decoratedComponentA);

        // 调用装饰后的组件对象的 Operation() 方法
        decoratedComponentB.Operation();
    }
}
输出结果：
我是装饰器 B，在执行原有操作之前添加了一些功能
我是装饰器 A，在执行原有操作之前添加了一些功能
我是具体的组件，我执行了基本的操作
我是装饰器 A，在执行原有操作之后添加了一些功能
我是装饰器 B，在执行原有操作之后添加了一些功能
代码分析：
  • 我们首先创建了一个 ConcreteComponent 对象，它是具体组件类，提供了基本的功能。
  • 然后，我们使用 ConcreteDecoratorA 类包装了 ConcreteComponent 对象，为它添加了新的功能。
  • 接下来，我们使用 ConcreteDecoratorB 类再次包装了 ConcreteDecoratorA 对象，为它添加了更多的功能。
  • 最后，我们在 Main() 方法中调用了 decoratedComponentB.Operation() 方法，执行了装饰后的组件对象的操作。可以看到，装饰器 A 和装饰器 B 分别在执行原有操作之前和之后添加了新的功能。
幽默小贴士：

基本装饰器模式就像是“魔法调料瓶”，你可以通过它为任何菜肴添加不同的风味，而不需要重新烹饪整个菜品。就像《爱丽丝梦游仙境》中的疯狂茶会一样，你可以通过装饰器模式为每一杯茶添加不同的配料，让每一杯都变得独一无二！ 🍵

示例 2：咖啡店的饮品系统
using System;

// 定义饮品接口
public interface IBeverage
{
    string GetDescription();
    decimal Cost();
}

// 实现具体饮品类 1
public class Espresso : IBeverage
{
    public string GetDescription()
    {
        return "浓缩咖啡";
    }

    public decimal Cost()
    {
        return 1.99m;
    }
}

// 实现具体饮品类 2
public class HouseBlend : IBeverage
{
    public string GetDescription()
    {
        return "家庭混合咖啡";
    }

    public decimal Cost()
    {
        return 0.89m;
    }
}

// 定义装饰器类的基类
public abstract class CondimentDecorator : IBeverage
{
    protected IBeverage _beverage;

    public CondimentDecorator(IBeverage beverage)
    {
        _beverage = beverage;
    }

    public virtual string GetDescription()
    {
        return _beverage.GetDescription();
    }

    public virtual decimal Cost()
    {
        return _beverage.Cost();
    }
}

// 实现具体装饰器类 1
public class Milk : CondimentDecorator
{
    public Milk(IBeverage beverage) : base(beverage)
    {
    }

    public override string GetDescription()
    {
        return base.GetDescription() + ", 加牛奶";
    }

    public override decimal Cost()
    {
        return base.Cost() + 0.20m;
    }
}

// 实现具体装饰器类 2
public class Mocha : CondimentDecorator
{
    public Mocha(IBeverage beverage) : base(beverage)
    {
    }

    public override string GetDescription()
    {
        return base.GetDescription() + ", 加摩卡";
    }

    public override decimal Cost()
    {
        return base.Cost() + 0.50m;
    }
}

// 实现具体装饰器类 3
public class Whip : CondimentDecorator
{
    public Whip(IBeverage beverage) : base(beverage)
    {
    }

    public override string GetDescription()
    {
        return base.GetDescription() + ", 加鲜奶油";
    }

    public override decimal Cost()
    {
        return base.Cost() + 0.30m;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建一杯浓缩咖啡
        IBeverage beverage = new Espresso();
        Console.WriteLine($"{beverage.GetDescription()} 的价格是 {beverage.Cost():C}");

        // 为浓缩咖啡添加牛奶和摩卡
        beverage = new Milk(beverage);
        beverage = new Mocha(beverage);
        Console.WriteLine($"{beverage.GetDescription()} 的价格是 {beverage.Cost():C}");

        // 创建一杯家庭混合咖啡
        IBeverage houseBlend = new HouseBlend();
        Console.WriteLine($"{houseBlend.GetDescription()} 的价格是 {houseBlend.Cost():C}");

        // 为家庭混合咖啡添加牛奶、摩卡和鲜奶油
        houseBlend = new Milk(houseBlend);
        houseBlend = new Mocha(houseBlend);
        houseBlend = new Whip(houseBlend);
        Console.WriteLine($"{houseBlend.GetDescription()} 的价格是 {houseBlend.Cost():C}");
    }
}
输出结果：
浓缩咖啡 的价格是 $1.99
浓缩咖啡, 加牛奶, 加摩卡 的价格是 $2.69
家庭混合咖啡 的价格是 $0.89
家庭混合咖啡, 加牛奶, 加摩卡, 加鲜奶油 的价格是 $1.89
代码分析：
  • 我们定义了一个 IBeverage 接口，它定义了所有饮品的公共行为，包括 GetDescription() 和 Cost() 方法。
  • 然后，我们实现了 Espresso 和 HouseBlend 两个具体饮品类，它们分别代表浓缩咖啡和家庭混合咖啡。
  • 接下来，我们定义了一个 CondimentDecorator 类，它是装饰器类的基类，持有一个对 IBeverage 对象的引用。装饰器类负责为被装饰的饮品添加新的配料，并调整其价格。
  • 最后，我们在 Main() 方法中创建了两杯饮品，并通过装饰器类为它们添加了不同的配料。可以看到，每次添加新的配料时，饮品的价格和描述都会相应地发生变化。
幽默小贴士：

在咖啡店的饮品系统中，装饰器模式就像是“魔法调料瓶”，你可以通过它为每一杯咖啡添加不同的配料，让每一杯都变得独一无二。就像《爱丽丝梦游仙境》中的疯狂茶会一样，你可以通过装饰器模式为每一杯茶添加不同的配料，让每一杯都变得独一无二！ ☕

第六节：注意事项

虽然装饰器模式非常有用，但在使用时也有一些需要注意的地方：

  1. 避免过度使用：

    • 装饰器模式适用于那些需要动态添加功能的场景。如果你的功能组合相对固定，或者装饰器的层次过于复杂，可能会导致代码难以维护。因此，应该谨慎使用装饰器模式，确保它真正能够简化你的代码。

  2. 保持装饰器类的简单性：

    • 装饰器类应该尽量保持简单，只负责为被装饰的对象添加新的功能。不要在装饰器类中添加过多的业务逻辑，以免增加维护难度。

  3. 支持多态性：

    • 装饰器模式允许你在运行时动态地选择要添加的功能，而不需要硬编码具体的类名。你可以根据不同的条件为对象添加不同的装饰器，从而使代码更加灵活。

  4. 避免无限递归：

    • 在实现装饰器模式时，确保不会出现无限递归的情况。例如，如果装饰器类在调用 Operation() 方法时没有正确调用被装饰对象的 Operation() 方法，可能会导致递归调用，最终引发栈溢出错误。
幽默小贴士：

装饰器模式虽然强大，但也需要谨慎使用。毕竟，即使是“魔法调料瓶”也需要懂得适可而止，不能随便添加过多的调料！ 🍵

第七节：本章总结

在这章中，我们学习了 装饰器模式 的基本概念、应用场景、实现方法以及注意事项。装饰器模式提供了一种动态地为对象添加新功能的方式，而不需要修改原有的类。它在避免类爆炸、支持多态性和提高代码灵活性方面有着重要的作用。

我们通过两个实际的代码示例展示了如何在 C# 中实现装饰器模式，包括基本装饰器模式和咖啡店的饮品系统。最后，我们还讨论了一些使用装饰器模式时需要注意的地方，帮助你在实际开发中做出明智的选择。

幽默小贴士：

装饰器模式就像是编程世界里的“魔法调料瓶”，你可以通过它为任何菜肴添加不同的风味，而不需要重新烹饪整个菜品。就像《爱丽丝梦游仙境》中的疯狂茶会一样，你可以通过装饰器模式为每一杯茶添加不同的配料，让每一杯都变得独一无二！ 🍵

结束语

亲爱的学员们，恭喜你完成了 C# 设计模式 的第六章！通过学习装饰器模式，你已经掌握了如何通过装饰器类为对象动态地添加新功能，而不需要修改现有的代码。接下来，我们将继续探索更多的设计模式，帮助你编写更加优雅、灵活和可维护的代码。

# c# # 设计模式 # 装饰器模式 # 开发语言
Logo
天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

deck.gl TripsLayer 出租车轨迹动画示例实战：从示例运行到着色器原理

TripsLayer 是 deck.gl 中用于渲染**随时间流动的轨迹动画**（如出租车行程、物流路径、迁徙路线）的核心图层。本文以仓库中的最小独立示例 [examples/website/trips](https://link.gitcode.com/i/1442af8f442f4cff39ff546e050fceb5) 为骨架，带你完成从安装依赖、启动应用、理解曼哈顿出租车数据格式，到深入

avatar 天工造物局

Foundry Anvil 中 eth_simulateV1 的 Blob 交易与 Blob Gas 字段规范化：原理、实现与测试验证

本篇技术指南以 [anvil-simulate-blob-transactions.md](https://link.gitcode.com/i/3d2ebe227262de169335eb290af80da8) 这条 changelog 条目为起点，深入剖析 Foundry Anvil 对 `eth_simulateV1` RPC 返回结果中 blob（EIP-4844）交易与 blob gas

avatar 天工造物局

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能

avatar 天工造物局