装饰器模式

概述

装饰器模式是一种结构型设计模式，其主要思想是在不改变原始对象的结构的情况下，通过将对象包装在装饰器类中，动态地为对象添加额外的功能或责任。该模式通过组合方式实现功能的增强，而不是通过继承来扩展对象的行为。

思想

主要思想包括以下几点：

1. 透明性： 装饰器模式要求装饰器类与原始对象实现相同的接口，使得客户端可以像操作原始对象一样操作装饰器对象，从而达到透明性的目的。

2. 动态性： 装饰器模式允许在运行时动态地添加额外的功能，而不需要修改原始对象的代码。通过将对象包装在装饰器类中，可以在不改变原始对象结构的情况下，为其添加新的行为或功能。

3. 组合性： 装饰器模式通过组合方式实现功能的增强，而不是通过继承。装饰器类通常包含一个指向原始对象的引用，并通过调用原始对象的方法来实现额外的功能。

4. 单一职责原则： 装饰器模式遵循单一职责原则，每个装饰器类只负责添加一个特定的功能，从而使得类的责任更加明确和单一。

5. 可扩展性： 由于装饰器模式采用了组合方式实现功能的增强，因此可以灵活地添加新的装饰器类来扩展对象的功能，而不需要修改现有的代码。

结构

装饰器模式包括以下关键组件：

1. Component（组件）：定义一个接口，用于规范具体组件类的接口。

2. ConcreteComponent（具体组件）：实现组件接口，是被装饰的原始类。

3. Decorator（装饰器）：继承自Component，包含一个指向Component的引用，并且实现了与Component一致的接口。这是一个抽象类，通常包含一个抽象的装饰方法，该方法可以调用被装饰对象的方法，同时添加额外的功能。

4. ConcreteDecorator（具体装饰器）：扩展自Decorator，它实现了装饰方法，并可以在调用被装饰对象的方法之前或之后执行额外的操作。

示例

using System;
​
// Component
public interface ICoffee
{
    string GetDescription();
    double Cost();
}
​
// ConcreteComponent
public class SimpleCoffee : ICoffee
{
    public string GetDescription()
    {
        return "Simple coffee";
    }
​
    public double Cost()
    {
        return 1.0;
    }
}
​
// Decorator
public abstract class CoffeeDecorator : ICoffee
{
    protected ICoffee _coffee;
​
    public CoffeeDecorator(ICoffee coffee)
    {
        _coffee = coffee;
    }
​
    public virtual string GetDescription()
    {
        return _coffee.GetDescription();
    }
​
    public virtual double Cost()
    {
        return _coffee.Cost();
    }
}
​
// ConcreteDecorator
public class MilkDecorator : CoffeeDecorator
{
    public MilkDecorator(ICoffee coffee) : base(coffee) { }
​
    public override string GetDescription()
    {
        return base.GetDescription() + ", Milk";
    }
​
    public override double Cost()
    {
        return base.Cost() + 0.5;
    }
}
​
public class SugarDecorator : CoffeeDecorator
{
    public SugarDecorator(ICoffee coffee) : base(coffee) { }
​
    public override string GetDescription()
    {
        return base.GetDescription() + ", Sugar";
    }
​
    public override double Cost()
    {
        return base.Cost() + 0.2;
    }
}
​
class Program
{
    static void Main(string[] args)
    {
        // Order a simple coffee
        ICoffee simpleCoffee = new SimpleCoffee();
        Console.WriteLine("Description: " + simpleCoffee.GetDescription());
        Console.WriteLine("Cost: $" + simpleCoffee.Cost());
​
        // Order a coffee with milk
        ICoffee coffeeWithMilk = new MilkDecorator(new SimpleCoffee());
        Console.WriteLine("\nDescription: " + coffeeWithMilk.GetDescription());
        Console.WriteLine("Cost: $" + coffeeWithMilk.Cost());
​
        // Order a coffee with milk and sugar
        ICoffee coffeeWithMilkAndSugar = new SugarDecorator(new MilkDecorator(new SimpleCoffee()));
        Console.WriteLine("\nDescription: " + coffeeWithMilkAndSugar.GetDescription());
        Console.WriteLine("Cost: $" + coffeeWithMilkAndSugar.Cost());
    }
}

优缺点

优点

• 灵活性：可以在运行时动态地为对象添加新的功能，而不需要修改其原始代码。

• 可重用性：装饰器可以被多次使用，可以通过组合不同的装饰器来实现不同的行为组合。

缺点

• 复杂性：如果使用不当，可能会导致类的层级结构变得复杂，不利于维护和理解。

• 过多的对象：如果有太多的装饰器类，可能会导致对象的数量剧增，增加了系统的复杂性。

适用场景

装饰器模式适用于以下情况：

• 当需要在不修改现有代码的情况下，动态地为对象添加新功能时。

• 当希望将责任划分到单个类中，以便在不同的时候独立扩展或修改时。

• 当有多个对象拥有共同的行为，但每个对象可能需要独立地增强这些行为时。