合成复用原则（Composite Reuse Principle，CRP）

合成复用原则 是面向对象设计中的一条原则，它强调通过对象的组合（composition）来实现功能复用，而不是通过继承。具体来说，合成复用原则认为应该优先使用对象组合来扩展功能，而不是通过类继承来进行功能扩展。这样可以减少继承带来的紧耦合问题，增强系统的灵活性和可维护性。

主要思想：

组合：通过将现有类作为新类的成员，达到重用功能的目的。
继承：通过从现有类派生子类进行功能扩展。
合成复用原则更倾向于使用组合而不是继承，因为组合具有更好的灵活性，减少了类与类之间的耦合。

合成复用原则的优点：

降低耦合度：组合比继承更松散，减少了类之间的强依赖。
提高灵活性：组合允许在运行时动态更改或替换所使用的对象，而继承是一种静态的、编译时的行为。
增强可维护性：通过对象组合，我们可以更方便地修改和扩展类的功能，而不会影响其他类。

合成复用原则在开发中的使用

在实际开发中，优先考虑对象组合的设计模式和编程习惯都可以很好地体现合成复用原则。以下是一些常见的场景和例子。

1. 策略模式（Strategy Pattern）

策略模式允许在运行时选择算法或策略，并通过对象组合的方式将不同的策略对象传递给使用者，而不需要通过继承来实现算法的变化。

// 定义策略接口
public interface IPaymentStrategy
{
    void Pay(decimal amount);
}

// 具体策略实现
public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using credit card.");
    }
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using PayPal.");
    }
}

// 上下文类
public class PaymentContext
{
    private IPaymentStrategy _paymentStrategy;

    // 通过组合策略对象
    public PaymentContext(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void ExecutePayment(decimal amount)
    {
        _paymentStrategy.Pay(amount);
    }
}

// 客户端使用
class Program
{
    static void Main(string[] args)
    {
        // 使用不同的支付策略
        var paymentContext = new PaymentContext(new CreditCardPayment());
        paymentContext.ExecutePayment(100);

        paymentContext = new PaymentContext(new PayPalPayment());
        paymentContext.ExecutePayment(200);
    }
}

在这个例子中，PaymentContext 类通过组合 IPaymentStrategy 实现了支付策略的灵活切换，而不需要通过继承扩展具体的支付方式。这正是合成复用原则的应用。

2. 装饰器模式（Decorator Pattern）

装饰器模式允许在不修改原有类的情况下，通过对象组合的方式动态地为对象添加功能。这是比继承更灵活的复用方式。

// 定义接口
public interface IMessage
{
    string GetMessage();
}

// 原始实现类
public class SimpleMessage : IMessage
{
    public string GetMessage()
    {
        return "This is a simple message.";
    }
}

// 装饰器基类
public class MessageDecorator : IMessage
{
    protected IMessage _message;

    public MessageDecorator(IMessage message)
    {
        _message = message;
    }

    public virtual string GetMessage()
    {
        return _message.GetMessage();
    }
}

// 具体装饰器
public class EncryptedMessageDecorator : MessageDecorator
{
    public EncryptedMessageDecorator(IMessage message) : base(message) { }

    public override string GetMessage()
    {
        return EncryptMessage(_message.GetMessage());
    }

    private string EncryptMessage(string message)
    {
        return $"[Encrypted] {message}";
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        IMessage simpleMessage = new SimpleMessage();
        Console.WriteLine(simpleMessage.GetMessage());

        // 使用装饰器扩展功能
        IMessage encryptedMessage = new EncryptedMessageDecorator(simpleMessage);
        Console.WriteLine(encryptedMessage.GetMessage());
    }
}

在这个例子中，通过组合 IMessage，可以在不改变原有 SimpleMessage 类的基础上，为其添加加密功能。这比通过继承来扩展功能更加灵活，也符合合成复用原则。

3. 依赖注入（Dependency Injection）

在 .NET 的依赖注入（DI）机制中，通过构造函数注入对象依赖，而不是通过继承来获取依赖的对象，这也是合成复用原则的一个应用。

public class UserService
{
    private readonly ILogger _logger;

    // 通过构造函数注入，而不是继承获取日志服务
    public UserService(ILogger logger)
    {
        _logger = logger;
    }

    public void CreateUser(string userName)
    {
        _logger.Log($"Creating user: {userName}");
        // 创建用户逻辑
    }
}

这里通过将 ILogger 作为依赖注入到 UserService 中，而不是继承一个 Logger 类。这种设计方式使得 UserService 更加灵活，可以更轻松地替换或修改日志实现。

4. 组合优先于继承的实际案例

在很多库或框架中，往往优先使用组合来扩展功能，而不是通过继承。例如，ASP.NET Core 中的 Middleware 机制通过组合方式注入和构建中间件链，而不是通过继承去扩展已有中间件。

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

    public LoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        Console.WriteLine($"Request: {context.Request.Path}");
        await _next(context);
    }
}

这里的 LoggingMiddleware 使用了组合来包含 RequestDelegate，可以自由控制请求管道的执行顺序，而不是通过继承其他中间件类来实现功能。

总结

合成复用原则强调通过组合而非继承来复用功能，这样做的优点是降低耦合度、增强灵活性和可维护性。在开发中，通过策略模式、装饰器模式、依赖注入等设计模式，.NET 框架提供了大量合成复用的机会。这种设计方式让系统更具扩展性，也更容易维护。