限制子类继承基类的某些方法

Question

using System;

public class Base
{
    public Base()
    {
    }

    public void M1()
    {
    }

    public void M2()
    {
    }

    public void M3()
    {
    }
}

public class Derived : Base
{
    //this class should get only method 1
}

public class SecondDerived : Base
{
    //this class should get only method 2 and method3
}

要求是：基类包含 3 个方法 M1、M2、M3。
派生类应仅继承 M1，SecondDerived 应仅继承 M2 和 M3。

这怎么能做到呢？

Answer 1

可以通过添加 Obsolete 属性来实现

public class A
{
    public virtual void M1() { }
    public void M2() { }
    public void M3() { }
}

public class B : A
{
    [Obsolete("You can not use this", true)]
    public sealed override void M1()
    {

    }
}

public class C : B
{
    public void Test()
    {
        // Will show error 
        base.M1();

    }
}

Answer 2

您不能有选择地继承这样的方法。派生类自动继承基类的所有公共方法。我建议您将 Base 类拆分为两个类：

public class Base1
{
    public Base1()
    {
    }

    public void M1()
    {
    }
}

public class Base2
{
    public void M2()
    {        
    }

    public void M3()
    {       
    }
}

public class First : Base1

public class Second : Base2

Answer 3

你不能用这种方式来做。继承意味着“IS A”关系。

如果 SecondDerived 没有 M1() 那么它将与对 class Base 的引用不兼容。

因此，也许您不应该使用继承来解决您正在解决的任何问题。

Answer 4

通过继承不可能做你想做的事。

看来您无意覆盖，您只是想有选择地“继承”基类的行为。您可以使用“有”关系来做到这一点：

public class Base
{
     internal Base() {} //mark constructor as internal so it can not be used outside your assembly if necessary

     public Foo Mehtod1() {...}
     public Foo Mehtod2() {...}
     public Foo Mehtod3() {...}
}

然后只需执行以下操作：

class A
{
     private Base internalBase;

     public A() { this.internalBase = new Base(); }

     public Foo Method1() { return this.internalBase.Method1(); }
}

class B
{
     private Base internalBase;

     public A() { this.internalBase = new Base(); }

     public Foo Method2() { return this.internalBase.Method2(); }
     public Foo Method3() { return this.internalBase.Method3(); }
}

更新：一个可能的替代解决方案是使您的Base类方法virtual< /code> 并在派生类中重写它们，在您不希望该类提供的那些方法中抛出 NotSupportedException。我不太喜欢这个解决方案，但它的优点是不会失去多态性继承，如果您有一些所有派生类都将共享的核心基本功能，这可能会很有用（在您的示例中，您似乎暗示它们不会）。