如何防止具有公共派生类的抽象类在其他程序集中被继承？

Question

我想编写如下内容：

    internal class InternalData
    {
    }

    public class PublicData
    {
    }

    abstract internal class Base {
        internal Base() { }

        private static InternalData CreateInternalDataFromPublicData(PublicData publicData)
        {
            throw new NotImplementedException();
        }

        abstract protected void DoProcess(InternalData internalData);

        public void Process(PublicData publicData)
        {
            InternalData internalData = CreateInternalDataFromPublicData(publicData);
            DoProcess(internalData);
        }
    }

    public sealed class Derived : Base
    {
        protected override void DoProcess(InternalData internalData)
        {
            throw new NotImplementedException();
        }
    }

也就是说，Base 包含一些内部逻辑，并且不打算由程序集外部的类继承；并且Derived可以从外部访问。 InternalData 还包含一些内部逻辑，因为它永远不会（并且不应该）从外部使用，所以我也想将其设置为内部逻辑。

当然，上面的代码不会编译，因为 Base 的可访问性不应低于 Derived。我可以将 Base 设置为 public，这很好，但它会导致另一个问题。 如果Base是公共的，那么在其他程序集中可能有一些ExternalDerived：Base。但是 Base.DoProcess 接受 InternalData 作为其参数，因此 ExternalDerived 无法实现它（因为它不知道 内部数据）。 内部无参数 Base 构造函数会阻止创建任何 ExternalDerived 实例，因此没有人会实现 ExternalDerived.DoProcess 并且没有 InternalData需要公开曝光，但编译器不知道。

我如何重写上面的代码，以便有一个抽象的 DoProcess(InternalData) 方法，并且 InternalData 类将是内部的？

Answer 1

从 C# 7.2 开始，就有了 private protected 访问修饰符，这意味着“仅适用于同一程序集中的派生类”。

换句话说，它必须满足 internal 和 protected 的条件，这与适用于 internal OR 的 protected internal 不同受保护。

您可以将基类的构造函数标记为 private protected，从而有效地防止通过程序集外部的此构造函数继承该类，同时仍允许在该程序集（以及程序集的友元）内进行继承。

因此，像这样的类：

public abstract BaseClass
{
    private protected BaseClass() {}
}

有效地密封在程序集外部，同时仍然可以在程序集内继承。

Answer 2

要使 InternalData 成为内部数据，DoProcess 必须是 private 或 internal
（或 InternalAndProtected，但 C# 不支持此 CLR 功能）。它不能受保护或内部保护。

internal abstract DoProcess(InternalData internalData);

---

我可能还会添加一个内部抽象 void DoNotInheritFromThisClassInAnOutsideAssembly() 成员。这可以防止程序集外部的任何人从您的类继承，因为他们无法实现该成员并且会得到合理的编译器错误。但是您不能将Base 类本身设为内部类。

---

我会考虑重构代码，这样就没有公共基类了。可能是通过使用一些内部接口和组合。

Answer 3

闻起来你应该使用 组合而不是继承。抱歉，这是一个非常模糊的答案。我现在更多地考虑这个问题..

Answer 4

基类型必须是可访问的，否则就不可能找出它的基类型。您的 Base 直接派生自 System.Object，但是 Derived 的用户如何知道这一点呢？它如何知道 Base 不是从另一个公共类型派生的，并且该类型的成员应该可用？

如果将 Base 中的所有内容标记为内部（类本身除外），那么您就已经阻止了其他程序集使用它执行任何有用的操作。换句话说，如果将 DoProcess 设为内部，则可以防止 InternalData 变为 public。

是的，无可否认，如果其他类尝试调用 DoProcess，那么您自己的程序集中可能会出现错误。不幸的是，没有“可从同一程序集中的派生类访问”访问修饰符，只有“可从派生类访问”、“可从同一程序集访问”和“可从派生类访问并可从同一程序集访问”。 （实际上，.NET 确实支持它，但 C# 不支持。）

Answer 5

将Base设置为public。

public abstract class Base {...

更改Base.DoProcess：

protected virtual void DoProcess<T>(T internalData)
{
    if (!(internalData is InternalData))
    {
        throw new ArgumentOutOfRangeException("internalData");
    }
}

更改Derived.DoProcess： >

protected override void DoProcess<T>(T internalData)
{
    base.DoProcess(internalData);
    // Other operations
}

Answer 6

它实际上非常简单。您只需要派生类实现抽象内部方法即可。库外部的类将无法实现抽象方法，因此在编译时失败。

您的示例已最小化，仅包含必需品：

abstract internal class Base {
    internal protected abstract void DoProcess();

    public void Process() {
        DoProcess();
    }
}

public sealed class Derived : Base {
    internal protected override void DoProcess() {
        throw new NotImplementedException();
    }
}