C#中如何为不同外部父类的子类实例附加相同代码且避免重复？

我有多个来自类库的父类（如A、D、F），分别子类化得到B:A、C:D、E:F等类。需要为B、C、E的每个实例添加大量相同的代码（包括字段状态和方法），但不想重复编写。
理想方案是多继承，但C#不支持。曾考虑用特性实现：

[MyAttributeWithState(foo, bar)]
public class A : B {
  // 类A的专属代码
}

但类特性是针对类型而非实例的，整个类型只有一个状态，而我需要每个实例拥有独立状态。求可行的替代方案。

1. 组合模式（推荐） #

核心思路是用“拥有”（Has-A）替代“继承”（Is-A）：创建一个封装了通用状态和方法的独立类，让B、C、E等子类各自持有这个类的实例，每个子类实例会对应独立的通用状态，方法通过委托暴露即可。

示例代码：

// 封装通用状态与方法的类
public class CommonBehavior
{
    // 实例独立的状态字段
    public int Counter { get; private set; }

    public void IncrementCounter()
    {
        Counter++;
    }

    public string GetStatus()
    {
        return $"当前计数：{Counter}";
    }
}

// 子类B的实现
public class B : A
{
    // 每个B实例都有自己的CommonBehavior实例
    private readonly CommonBehavior _commonBehavior = new CommonBehavior();

    // 委托通用方法，对外提供统一接口
    public void IncrementCounter() => _commonBehavior.IncrementCounter();
    public string GetStatus() => _commonBehavior.GetStatus();

    // B的专属业务代码
    public void DoSpecificTaskForB()
    {
        // ...
    }
}

这种方式完全满足实例状态独立的需求，是C#中替代多继承的标准方案，唯一小缺点是如果通用方法较多，需要手动编写委托代码，但可以通过定义接口来约束子类的实现规范。

2. 接口+扩展方法 #

如果通用方法逻辑不依赖私有状态，或者状态可以通过接口暴露的属性维护，可以定义一个通用接口，让所有目标子类实现该接口，再用扩展方法实现通用逻辑。状态仍需每个子类自行维护，但方法无需重复编写。

示例代码：

// 定义通用接口，约定需要暴露的状态
public interface ICommon
{
    int Counter { get; set; }
}

// 用扩展方法实现通用逻辑
public static class CommonExtensions
{
    public static void IncrementCounter(this ICommon common)
    {
        common.Counter++;
    }

    public static string GetStatus(this ICommon common)
    {
        return $"当前计数：{common.Counter}";
    }
}

// 子类B实现接口
public class B : A, ICommon
{
    // 每个B实例独立的状态
    public int Counter { get; set; }

    // B的专属业务代码
    public void DoSpecificTaskForB()
    {
        // ...
    }
}

适用场景：通用方法逻辑相对独立，不需要访问子类私有成员的情况。优点是方法复用高效，缺点是状态需要每个子类单独声明。

3. 动态代理（如Castle DynamicProxy） #

通过动态代理在运行时为子类实例注入通用状态和方法，无需修改现有子类代码。适合需要批量给多个类添加统一行为的场景，但需要引入第三方库。

示例代码（简化版）：

using Castle.DynamicProxy;
using System.Collections.Generic;

// 通用拦截器，维护实例状态并处理通用方法
public class CommonInterceptor : IInterceptor
{
    // 用字典存储每个实例的独立状态，key为实例引用
    private readonly Dictionary<object, int> _instanceCounters = new Dictionary<object, int>();

    public void Intercept(IInvocation invocation)
    {
        // 处理通用方法调用
        if (invocation.Method.Name == "IncrementCounter")
        {
            if (!_instanceCounters.ContainsKey(invocation.InvocationTarget))
            {
                _instanceCounters[invocation.InvocationTarget] = 0;
            }
            _instanceCounters[invocation.InvocationTarget]++;
            return;
        }
        else if (invocation.Method.Name == "GetStatus")
        {
            var count = _instanceCounters.TryGetValue(invocation.InvocationTarget, out int c) ? c : 0;
            invocation.ReturnValue = $"当前计数：{count}";
            return;
        }

        // 非通用方法，调用原类逻辑
        invocation.Proceed();
    }
}

// 代理实例创建工具
public static class ProxyFactory
{
    public static T CreateWithCommonBehavior<T>() where T : class, new()
    {
        var proxyGenerator = new ProxyGenerator();
        return proxyGenerator.CreateClassProxy<T>(new CommonInterceptor());
    }
}

// 使用方式
var bInstance = ProxyFactory.CreateWithCommonBehavior<B>();
bInstance.IncrementCounter();
Console.WriteLine(bInstance.GetStatus()); // 输出：当前计数：1

优点：无需修改现有子类代码，统一在拦截器中管理通用逻辑；缺点：依赖第三方库，且要求子类方法为virtual或public才能被拦截。

4. 代码生成工具（T4模板/Roslyn） #

如果子类数量固定或有规律可循，可以用代码生成工具自动生成包含通用状态和方法的子类代码。比如用T4模板遍历目标父类，批量生成子类代码，兼顾通用逻辑和专属业务代码。

示例T4模板片段：

<#@ template language="C#" #>
<#@ output extension=".cs" #>

namespace YourNamespace
{
    // 自动生成的子类B
    public class B : A, ICommon
    {
        public int Counter { get; set; }

        public void IncrementCounter() => CommonExtensions.IncrementCounter(this);
        public string GetStatus() => CommonExtensions.GetStatus(this);

        // 预留专属代码区域，可手动补充
        public void DoSpecificTaskForB()
        {
            // ...
        }
    }

    // 自动生成的子类C
    public class C : D, ICommon
    {
        public int Counter { get; set; }

        public void IncrementCounter() => CommonExtensions.IncrementCounter(this);
        public string GetStatus() => CommonExtensions.GetStatus(this);

        // 预留专属代码区域，可手动补充
        public void DoSpecificTaskForC()
        {
            // ...
        }
    }
}

优点：一次性生成所有代码，无运行时额外开销；缺点：通用逻辑变更时需要重新生成代码，需维护模板规则。

内容的提问来源于stack exchange，提问作者Sebastian Barth