结构型设计模式之装饰模式

1. 装饰模式概述

装饰模式(Decorator Pattern)是一种结构型设计模式，它允许向一个现有的对象添加新的功能，同时又不改变其结构。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

装饰模式的核心思想是：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式比继承更为灵活，符合"开闭原则"。

2. 模式结构

装饰模式主要包含以下几个核心角色：

• 抽象组件（Component）：定义一个对象接口，可以给这些对象动态添加职责
• 具体组件（ConcreteComponent）：定义一个对象，可以给这个对象添加一些职责
• 抽象装饰器（Decorator）：继承自抽象组件，并持有一个抽象组件的引用，它的主要职责是为Component添加新的责任
• 具体装饰器（ConcreteDecorator）：具体的装饰器类，负责向组件添加新的职责

3. 装饰模式与继承的区别

装饰模式和继承都是为了扩展对象的功能，但它们有着本质的不同：

装饰模式使用组合而非继承来扩展功能，遵循了"多用组合，少用继承"的设计原则，避免了继承带来的类爆炸问题，同时提供了更大的灵活性。

4. 装饰模式的优缺点

优点

1. 扩展性强：可以在不修改现有对象结构的情况下，动态地添加功能
2. 符合开闭原则：对扩展开放，对修改关闭
3. 比继承更加灵活：可以通过不同装饰器的排列组合，创造出不同行为的组合
4. 避免类爆炸：使用多个小类进行组合，而不是创建大量功能不同的子类
5. 可以动态添加或删除责任：在运行时根据需求增减功能

缺点

1. 增加系统复杂度：需要创建大量小对象，加大了系统的复杂度
2. 可能产生很多小对象：装饰模式要求被装饰的组件和所有装饰器必须是同一类型
3. 不容易理解：多层装饰器的调试可能比较困难，需要剥离多层装饰来分析问题
4. 可能增加对象创建的复杂度：需要实例化并管理多个对象

5. C#代码示例

5.1 基本示例 - 饮料与调料

以下是一个咖啡店饮料系统的示例，使用装饰模式来添加不同的调料：

using System;

// 抽象组件类 - 饮料
public abstract class Beverage
{
    protected string description = "未知饮料";
    
    // 获取描述
    public virtual string GetDescription()
    {
        return description;
    }
    
    // 计算价格（抽象方法，由具体子类实现）
    public abstract double Cost();
}

// 具体组件类 - 浓缩咖啡
public class Espresso : Beverage
{
    // 构造函数中设置描述
    public Espresso()
    {
        description = "浓缩咖啡";
    }
    
    // 实现Cost方法返回价格
    public override double Cost()
    {
        return 19.0;
    }
}

// 具体组件类 - 黑咖啡
public class HouseBlend : Beverage
{
    public HouseBlend()
    {
        description = "黑咖啡";
    }
    
    public override double Cost()
    {
        return 15.0;
    }
}

// 抽象装饰器类 - 调料
public abstract class CondimentDecorator : Beverage
{
    // 所有调料装饰器必须重新实现GetDescription方法
    public abstract override string GetDescription();
}

// 具体装饰器类 - 牛奶
public class Milk : CondimentDecorator
{
    // 持有一个被装饰对象的引用
    private Beverage beverage;
    
    // 构造函数需要一个饮料作为参数
    public Milk(Beverage beverage)
    {
        this.beverage = beverage;
    }
    
    // 在原有描述的基础上添加牛奶描述
    public override string GetDescription()
    {
        return beverage.GetDescription() + "，加牛奶";
    }
    
    // 在原有价格的基础上加上牛奶的价格
    public override double Cost()
    {
        return beverage.Cost() + 2.0;
    }
}

// 具体装饰器类 - 摩卡
public class Mocha : CondimentDecorator
{
    private Beverage beverage;
    
    public Mocha(Beverage beverage)
    {
        this.beverage = beverage;
    }
    
    public override string GetDescription()
    {
        return beverage.GetDescription() + "，加摩卡";
    }
    
    public override double Cost()
    {
        return beverage.Cost() + 3.0;
    }
}

// 具体装饰器类 - 奶泡
public class Whip : CondimentDecorator
{
    private Beverage beverage;
    
    public Whip(Beverage beverage)
    {
        this.beverage = beverage;
    }
    
    public override string GetDescription()
    {
        return beverage.GetDescription() + "，加奶泡";
    }
    
    public override double Cost()
    {
        return beverage.Cost() + 1.5;
    }
}

// 客户端代码
public class CoffeeShop
{
    public static void Main(string[] args)
    {
        // 点一杯浓缩咖啡
        Beverage beverage1 = new Espresso();
        Console.WriteLine($"{beverage1.GetDescription()} ¥{beverage1.Cost()}");
        
        // 点一杯黑咖啡，加双倍摩卡和奶泡
        Beverage beverage2 = new HouseBlend();
        beverage2 = new Mocha(beverage2);     // 包装一次
        beverage2 = new Mocha(beverage2);     // 包装两次
        beverage2 = new Whip(beverage2);      // 包装三次
        Console.WriteLine($"{beverage2.GetDescription()} ¥{beverage2.Cost()}");
        
        // 点一杯浓缩咖啡，加牛奶和奶泡
        Beverage beverage3 = new Espresso();
        beverage3 = new Milk(beverage3);
        beverage3 = new Whip(beverage3);
        Console.WriteLine($"{beverage3.GetDescription()} ¥{beverage3.Cost()}");
    }
}

/* 输出:
浓缩咖啡 ¥19
黑咖啡，加摩卡，加摩卡，加奶泡 ¥22.5
浓缩咖啡，加牛奶，加奶泡 ¥22.5
*/

5.2 更复杂的示例 - 文本格式化器

下面是一个使用装饰模式实现的文本格式化系统，可以动态地给文本添加不同的格式化效果：

using System;
using System.Text;

// 抽象组件 - 文本接口
public interface IText
{
    string GetContent();
}

// 具体组件 - 普通文本
public class PlainText : IText
{
    private string content;
    
    public PlainText(string content)
    {
        this.content = content;
    }
    
    public string GetContent()
    {
        return content;
    }
}

// 抽象装饰器 - 文本格式化装饰器
public abstract class TextDecorator : IText
{
    protected IText text;
    
    public TextDecorator(IText text)
    {
        this.text = text;
    }
    
    // 默认实现是委托给包装的对象
    public virtual string GetContent()
    {
        return text.GetContent();
    }
}

// 具体装饰器 - 粗体装饰器
public class BoldDecorator : TextDecorator
{
    public BoldDecorator(IText text) : base(text) {}
    
    // 重写GetContent方法，添加粗体标记
    public override string GetContent()
    {
        // 在原有内容的基础上添加粗体标记
        return $"<b>{text.GetContent()}</b>";
    }
}

// 具体装饰器 - 斜体装饰器
public class ItalicDecorator : TextDecorator
{
    public ItalicDecorator(IText text) : base(text) {}
    
    public override string GetContent()
    {
        return $"<i>{text.GetContent()}</i>";
    }
}

// 具体装饰器 - 下划线装饰器
public class UnderlineDecorator : TextDecorator
{
    public UnderlineDecorator(IText text) : base(text) {}
    
    public override string GetContent()
    {
        return $"<u>{text.GetContent()}</u>";
    }
}

// 具体装饰器 - 颜色装饰器
public class ColorDecorator : TextDecorator
{
    private string color;
    
    // 构造器需要额外的颜色参数
    public ColorDecorator(IText text, string color) : base(text)
    {
        this.color = color;
    }
    
    public override string GetContent()
    {
        return $"<span style=\"color:{color}\">{text.GetContent()}</span>";
    }
}

// 客户端代码
public class TextEditor
{
    public static void Main(string[] args)
    {
        // 创建一个普通文本
        IText text = new PlainText("Hello, Decorator Pattern!");
        Console.WriteLine("普通文本: " + text.GetContent());
        
        // 添加粗体格式
        IText boldText = new BoldDecorator(text);
        Console.WriteLine("粗体文本: " + boldText.GetContent());
        
        // 添加斜体格式
        IText italicText = new ItalicDecorator(text);
        Console.WriteLine("斜体文本: " + italicText.GetContent());
        
        // 组合多种格式：粗体 + 斜体
        IText boldItalicText = new BoldDecorator(new ItalicDecorator(text));
        Console.WriteLine("粗斜体文本: " + boldItalicText.GetContent());
        
        // 组合多种格式：红色 + 粗体 + 下划线
        IText complexText = new ColorDecorator(
                              new BoldDecorator(
                                new UnderlineDecorator(text)), "red");
        Console.WriteLine("复杂格式文本: " + complexText.GetContent());
    }
}

/* 输出:
普通文本: Hello, Decorator Pattern!
粗体文本: <b>Hello, Decorator Pattern!</b>
斜体文本: <i>Hello, Decorator Pattern!</i>
粗斜体文本: <b><i>Hello, Decorator Pattern!</i></b>
复杂格式文本: <span style="color:red"><b><u>Hello, Decorator Pattern!</u></b></span>
*/

6. C#中装饰器模式的实际应用

6.1 C# I/O 流处理

.NET框架中的I/O类就是装饰模式的典型应用。以下是一个使用C#流的示例：

using System;
using System.IO;
using System.Text;

public class StreamExample
{
    public static void Main(string[] args)
    {
        // 创建文件
        using (FileStream fileStream = new FileStream("example.txt", FileMode.Create))
        {
            // 装饰文件流，添加缓冲功能
            using (BufferedStream bufferedStream = new BufferedStream(fileStream))
            {
                // 再次装饰，添加文本写入功能
                using (StreamWriter writer = new StreamWriter(bufferedStream, Encoding.UTF8))
                {
                    // 使用最终装饰好的对象写入文本
                    writer.WriteLine("这是一个装饰模式的示例。");
                    writer.WriteLine("我们使用了多个装饰器来增强FileStream的功能：");
                    writer.WriteLine("1. BufferedStream添加了缓冲功能");
                    writer.WriteLine("2. StreamWriter添加了文本写入功能");
                }
                // 离开using块时，各个流会按顺序关闭
            }
        }
        
        Console.WriteLine("文件已成功写入，现在读取它：");
        
        // 读取文件
        using (FileStream fileStream = new FileStream("example.txt", FileMode.Open))
        {
            // 装饰文件流，添加缓冲功能
            using (BufferedStream bufferedStream = new BufferedStream(fileStream))
            {
                // 再次装饰，添加文本读取功能
                using (StreamReader reader = new StreamReader(bufferedStream, Encoding.UTF8))
                {
                    // 读取并输出所有文本
                    string content = reader.ReadToEnd();
                    Console.WriteLine(content);
                }
            }
        }
    }
}

在这个例子中，我们可以看到多个装饰器如何层层包装原始的FileStream对象，每一层都添加了新的功能：

• FileStream：提供对文件的基本读写功能
• BufferedStream：添加了缓冲功能，提高I/O性能
• StreamWriter/StreamReader：添加了文本写入/读取功能

6.2 ASP.NET Core 中间件

ASP.NET Core的中间件管道也是装饰模式的一个应用实例。每个中间件都可以处理请求，然后将请求传递给下一个中间件。

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Threading.Tasks;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 配置服务
    }
    
    // 配置HTTP请求管道
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 异常处理中间件
        app.UseExceptionHandler("/Home/Error");
        
        // 静态文件中间件
        app.UseStaticFiles();
        
        // 路由中间件
        app.UseRouting();
        
        // 认证中间件
        app.UseAuthentication();
        
        // 授权中间件
        app.UseAuthorization();
        
        // 自定义中间件
        app.Use(async (context, next) =>
        {
            // 请求前的处理
            Console.WriteLine($"请求开始: {context.Request.Path}");
            
            // 调用下一个中间件
            await next();
            
            // 请求后的处理
            Console.WriteLine($"请求结束: {context.Response.StatusCode}");
        });
        
        // 端点中间件
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

在这个例子中，每个中间件都可以视为一个装饰器，它们共同装饰HTTP请求和响应，添加各种功能，如异常处理、验证、授权等。

7. 装饰模式与其他设计模式的比较

装饰模式与其他几种常见的设计模式有一些相似之处，但也有明显的区别：

8. 装饰模式的实现步骤和最佳实践

实现装饰模式一般遵循以下步骤：

1. 创建抽象组件接口/类：定义所有具体组件和装饰器的公共接口
2. 实现具体组件类：实现抽象组件接口的基础功能
3. 创建抽象装饰器类：继承抽象组件，并持有一个抽象组件的引用
4. 实现具体装饰器类：继承抽象装饰器类，并添加新的功能
5. 客户端使用：客户端代码组合使用具体组件和各种装饰器

最佳实践

1. 保持接口一致性：装饰器应该与它所装饰的组件具有相同的接口，以保证透明性
2. 单一职责原则：每个装饰器应专注于添加单一的职责
3. 避免装饰器爆炸：太多的装饰器会使系统变得复杂，应适度使用
4. 考虑使用工厂或构建器模式：使用工厂或构建器模式可以简化复杂装饰器的创建
5. 注意装饰顺序：有时装饰器的应用顺序会影响最终行为

9. 装饰模式在实际项目中的注意事项

1. 接口的稳定性：如果接口经常变化，那么所有装饰器都需要更新，造成维护困难

2. 性能影响：每个装饰器都是一个对象，过多的装饰器可能导致性能下降和内存占用增加

3. 调试复杂度：多层装饰可能导致调试困难，因为需要逐层检查装饰器链

4. 文档和命名：为了提高代码可读性，应为每个装饰器提供清晰的文档和命名

5. 与依赖注入框架的结合：在使用依赖注入框架时，需要特别注意装饰器的注册和解析方式

10. 实际案例分析 - 日志系统

下面是一个使用装饰模式实现的可扩展日志系统：

using System;
using System.IO;

// 抽象组件 - 日志接口
public interface ILogger
{
    void Log(string message);
}

// 具体组件 - 基础控制台日志
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[INFO] {DateTime.Now}: {message}");
    }
}

// 具体组件 - 基础文件日志
public class FileLogger : ILogger
{
    private string filePath;
    
    public FileLogger(string filePath)
    {
        this.filePath = filePath;
    }
    
    public void Log(string message)
    {
        using (StreamWriter writer = File.AppendText(filePath))
        {
            writer.WriteLine($"[INFO] {DateTime.Now}: {message}");
        }
    }
}

// 抽象装饰器 - 日志装饰器
public abstract class LoggerDecorator : ILogger
{
    protected ILogger logger;
    
    public LoggerDecorator(ILogger logger)
    {
        this.logger = logger;
    }
    
    // 默认实现是委托给被装饰对象
    public virtual void Log(string message)
    {
        logger.Log(message);
    }
}

// 具体装饰器 - 时间戳装饰器
public class TimestampDecorator : LoggerDecorator
{
    public TimestampDecorator(ILogger logger) : base(logger) { }
    
    public override void Log(string message)
    {
        string timestampedMessage = $"[Timestamp: {DateTime.Now.Ticks}] {message}";
        logger.Log(timestampedMessage);
    }
}

// 具体装饰器 - 错误级别装饰器
public class ErrorLevelDecorator : LoggerDecorator
{
    private LogLevel level;
    
    public enum LogLevel
    {
        INFO,
        WARNING,
        ERROR,
        CRITICAL
    }
    
    public ErrorLevelDecorator(ILogger logger, LogLevel level) : base(logger)
    {
        this.level = level;
    }
    
    public override void Log(string message)
    {
        string leveledMessage = $"[{level}] {message}";
        logger.Log(leveledMessage);
    }
}

// 具体装饰器 - 加密装饰器
public class EncryptionDecorator : LoggerDecorator
{
    public EncryptionDecorator(ILogger logger) : base(logger) { }
    
    // 简单的模拟加密方法
    private string Encrypt(string message)
    {
        // 实际应用中会使用真正的加密算法
        return $"ENCRYPTED({message})";
    }
    
    public override void Log(string message)
    {
        string encryptedMessage = Encrypt(message);
        logger.Log(encryptedMessage);
    }
}

// 客户端代码
public class LoggingSystem
{
    public static void Main(string[] args)
    {
        // 1. 基础控制台日志
        ILogger consoleLogger = new ConsoleLogger();
        consoleLogger.Log("这是一条基础日志消息");
        
        // 2. 添加错误级别的控制台日志
        ILogger errorConsoleLogger = new ErrorLevelDecorator(
            consoleLogger, ErrorLevelDecorator.LogLevel.ERROR);
        errorConsoleLogger.Log("这是一条错误日志消息");
        
        // 3. 基础文件日志
        ILogger fileLogger = new FileLogger("log.txt");
        
        // 4. 带时间戳和错误级别的文件日志
        ILogger decoratedFileLogger = new TimestampDecorator(
            new ErrorLevelDecorator(fileLogger, ErrorLevelDecorator.LogLevel.WARNING));
        decoratedFileLogger.Log("这是一条带时间戳和警告级别的文件日志消息");
        
        // 5. 带加密的文件日志
        ILogger secureLogger = new EncryptionDecorator(fileLogger);
        secureLogger.Log("这是一条加密的日志消息");
        
        // 6. 复杂组合：带加密、时间戳和错误级别的控制台日志
        ILogger complexLogger = new EncryptionDecorator(
            new TimestampDecorator(
                new ErrorLevelDecorator(consoleLogger, ErrorLevelDecorator.LogLevel.CRITICAL)
            )
        );
        complexLogger.Log("这是一条高度安全的关键错误日志消息");
    }
}

这个例子展示了如何使用装饰模式创建一个灵活的日志系统，可以动态地组合各种日志功能。

11. 总结

装饰模式是一种灵活的结构型设计模式，它通过将对象包装在装饰器类中，以便动态地添加新行为。它遵循"开闭原则"，使我们能够在不修改现有代码的情况下扩展对象的功能。

装饰模式的核心优势在于：

1. 比静态继承更灵活，提供了更多的扩展性
2. 避免了类爆炸问题
3. 可以在运行时动态组合不同的行为
4. 符合单一职责原则，每个装饰器专注于一个功能

装饰模式在实际开发中有广泛的应用，特别是在需要动态扩展对象功能的场景中，如I/O处理、UI组件、权限系统等。

当我们需要在不修改现有代码的情况下为对象添加新的责任时，应该考虑使用装饰模式，它提供了一种灵活且可扩展的解决方案。

学习资源

1. Design Patterns: Elements of Reusable Object-Oriented Software - GoF经典著作
2. Head First Design Patterns - 生动易懂的设计模式入门书籍
3. Refactoring.Guru - Decorator Pattern
4. C# Design Pattern Essentials
5. Microsoft Learn - Design Patterns