C#中如何实现可继承两个抽象类之一且复用通用方法的派生类？

这个场景我太熟了！遇到这种不能修改外部类、又想复用代码还不想暴露内部敏感字段的情况，确实挺头疼的，不过咱们有几个靠谱的方案可以试试：

方案一：组合模式 + 受保护的内部辅助类（最推荐） #

这个方案能完美解决“不想暴露protected字段”的核心痛点，把通用逻辑封装在一个仅内部可见的辅助类里，既复用代码又守住访问权限。

首先咱们写一个受保护的辅助类，把所有通用方法和逻辑都塞进去，它通过构造函数接收基类实例，直接访问基类的protected成员：

// 这个辅助类仅在你的派生类内部可见，完全不会对外暴露
protected class CommonLogicHelper
{
    private readonly ExternalBaseClass _owner;

    public CommonLogicHelper(ExternalBaseClass owner)
    {
        _owner = owner;
    }

    // 这里就是你要复用的通用方法，直接通过_owner操作基类的protected成员
    public void MyCommonMethod()
    {
        // 比如调用ExternalBaseClass的protected方法
        _owner.ProtectedBaseMethod();
        // 或者处理通用业务逻辑
    }

    // 其他需要复用的方法都可以放在这里
}

然后你的两个派生类只需要持有这个辅助类的实例，调用它的方法就行：

public class MyClassA : ExternalA
{
    private readonly CommonLogicHelper _helper;

    public MyClassA()
    {
        _helper = new CommonLogicHelper(this);
    }

    protected void MyCommonMethod()
    {
        _helper.MyCommonMethod();
    }

    // MyClassA特有的方法写在这里
}

public class MyClassB : ExternalB
{
    private readonly CommonLogicHelper _helper;

    public MyClassB()
    {
        _helper = new CommonLogicHelper(this);
    }

    protected void MyCommonMethod()
    {
        _helper.MyCommonMethod();
    }

    // MyClassB特有的方法写在这里
}

这种方式既实现了代码复用，又完全不需要把内部敏感字段改成public，访问权限也能严格控制在protected级别。

方案二：T4代码生成模板（适合通用代码量极大的场景） #

如果你的通用逻辑特别多，手动写两次派生类太麻烦，可以用C#的T4模板自动生成代码，通用部分只需要写一次，生成的代码和手动编写的完全一致。

举个简单的T4模板示例：

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

public class MyClassA : ExternalA
{
    <#= GenerateCommonMethods() #>

    // 这里写MyClassA特有的方法
}

public class MyClassB : ExternalB
{
    <#= GenerateCommonMethods() #>

    // 这里写MyClassB特有的方法
}

<#+
private string GenerateCommonMethods()
{
    return @"
    protected void MyCommonMethod()
    {
        // 这里写通用逻辑代码
    }

    // 其他所有通用方法都放在这里
";
}
#>

模板会自动帮你生成两个包含通用代码的派生类，一劳永逸解决重复代码问题，而且完全不涉及字段暴露的问题。

方案三：扩展方法（适合简单通用逻辑） #

如果你的通用逻辑不需要访问基类的protected成员，只是一些基于public/内部成员的操作，那扩展方法是最简洁的选择：

public static class ExternalBaseClassExtensions
{
    public static void MyCommonMethod(this ExternalBaseClass instance)
    {
        // 这里只能访问instance的public或internal成员
        // 适合逻辑简单、不需要触碰内部字段的场景
    }
}

然后在派生类里直接调用就行：

public class MyClassA : ExternalA
{
    protected void MyCommonMethod()
    {
        this.MyCommonMethod(); // 调用扩展方法
    }
}

不过这个方案的局限性很明显——碰不到protected成员，所以如果你的通用逻辑必须操作内部字段，还是优先用方案一。

内容来源于stack exchange