如何在 C# 中的两个抽象方法中只实现抽象类中的一个方法？

Question

在一个抽象类中有两个抽象方法 Method1() 和 Method2()， 但是我喜欢在派生类中只继承一个Method1()，怎么处理呢？

public abstract class BaseClass
{
    public abstract void Method1();

    public abstract void Method2();
}

Answer 1

真的你不能......如果你有（我真的会质疑原因）一些选项是：

如果你对所涉及的抽象类没有任何控制权，并且必须使用这个特定的抽象类，那么，唯一的办法就是让派生类中的实现抛出一个NotImplementedException。

 public MyDerivedClass: BaseClass
 {
     public override void Method1()
     {
          // implementation of Method1
     }
     public override void Method2()
     { throw new NotImplementedException(); }
 }

...或者创建另一个抽象基类，例如OnlyDOMethod1

 public abstract class OnlyDoMethod1
 { public abstract void Method1(); }

然后，修改Baseclass，使其继承自OnlyDoMethod1

 public abstract class BaseClass: OnlyDoMethod1
 {  public abstract void Method2(); }

并在您只需要Method1的任何地方使用OnlyDoMethod1

public MyDerivedClass: OnlyDoMethod1
{
   public override void Method1()
   {
      // implementation of Method1
   }
}

Answer 2

听起来您正在寻找的是接口。像这样的：

public interface ICanDoMethod1
{
    void Method1();
}

public interface ICanDoMethod2
{
    void Method2();
}

然后你可以在你的类中选择性地实现它们：

public class JustMethod1 : ICanDoMethod1
{
    // implement Method1 here
}

public class Both : ICanDoMethod1, ICanDoMethod2
{
    // implement both here
}

// etc.

本质上，任何给定的类都可以或不能多态地解释为任何给定的类型。如果你只想成为一种类型的part，那么你真正拥有的是两种类型。 C# 是单继承，因此要实现多种类型，您将使用接口。

---

相反，您也可以链接您的继承。像这样的：

public abstract class Base1
{
    public abstract void Method1();
}

public abstract class BaseBoth : Base1
{
    public abstract void Method2();
}

public class JustOne : Base1
{
    // only implement Method1 here
}

public class Both : BaseBoth
{
    // implement both here
}

如果选项堆叠，即如果您不希望能够选择并且想要“1”或“1 和 2”（但不仅仅是“2”），这将起作用。

---

作为最后的手段，您可以通过明确不实现其他方法来“选择性地实现”方法。它看起来像：

public class JustOne : BaseClass
{
    public override void Method1()
    {
        // implement
    }

    public override void Method2()
    {
        throw new NotImplementedException();
    }
}

但这将是一种反模式，您的对象会宣传他们故意不支持的功能。这意味着BaseClass 类型应该被认为是非常不稳定/不可靠的，因为任何消耗该类型的东西都无法知道它应该的实际行为。

---

最终，听起来你已经把你自己的类型画到了一个角落，你需要稍微支持一下并重新考虑它们。 Liskov 换人不应该如此掉以轻心。

Answer 3

这是违反 SOLID 原则之一Interface segregation principle 的基本示例

永远不应该强迫客户端实现它的接口 不使用或不应该强迫客户依赖他们的方法 不要使用

如果您有只需要一些方法的抽象，则需要将它们拆分为单独的抽象。

.NET 不支持类的多重继承，坚果有很好的解决方法来解决这个问题 -> 接口。

如果您关心您的代码，那么您只有一种选择 - 将抽象类拆分为两个单独的类，它们只有一种方法。

如果您只使用抽象，那么接口是更好的方法，因为您可以在一个类中实现多个接口。

public interface IMethodOne
{
    void Method1();
}

public interface IMethodTwo
{
    void Method2();
}

然后您可以在需要这两种方法的类中实现这两个接口。并且在需要一种方法的类中只使用一个接口。

public abstract class BaseClass : IMethodOne, IMethodTwo
{
    public abstract void Method1();
    public abstract void Method2();
}

一个方法的类

public abstract class BaseClassOneMethod : IMethodOne
{
    public abstract void Method1();
}