C#：有什么方法可以跳过多态性中的一个基调用吗？

Question

class GrandParent
{
    public virtual void Foo() { ... }
}

class Parent : GrandParent
{
    public override void Foo()
    {
       base.Foo();

       //Do additional work
    }
}

class Child : Parent
{
    public override void Foo()
    {
        //How to skip Parent.Foo and just get to the GrandParent.Foo base?

        //Do additional work
    }
}

---

如上面的代码所示，如​​何让 Child.Foo() 调用 GrandParent.Foo() 而不是调用 Parent.Foo()？ base.Foo() 首先将我带到 Parent 类。

Answer 1

如果你需要这个，你的设计就是错误的。
相反，请将每个类的逻辑放在 DoFoo 中，并且在不需要时不要调用 base.DoFoo。

class GrandParent
{
    public void Foo()
    {
        // base logic that should always run here:
        // ...

        this.DoFoo(); // call derived logic
    }

    protected virtual void DoFoo() { }
}

class Parent : GrandParent
{
    protected override void DoFoo()
    {    
       // Do additional work (no need to call base.DoFoo)
    }
}

class Child : Parent
{
    protected override void DoFoo()
    {  
        // Do additional work (no need to call base.DoFoo)
    }
}

Answer 2

我认为你的设计有问题。本质上，你想要“打破”多态性的规则。您说 Child 应该从 Parent 派生，但希望方便地跳过其父级中的实现。

重新思考你的设计。

Answer 3

不，无论如何这都不可靠。作为您的类的实现者，您可以选择您的直接基类。但谁说 Parent 的更高版本可能不会从 ParentBase 继承，而后者又从 GrandParent 继承呢？只要 Parent 仍然实现正确的契约，这就不会对那些继承自 Parent 的类造成任何问题。

Answer 4

不，这是不可能的。想象一下，如果这可能的话，事情将会多么疯狂。

如果您希望在 Child 情况下跳过某些特定内容，请考虑重新设计您的设计以更好地表示您需要的内容（例如，也许您还需要覆盖 Child 类中的其他内容）。或者，您可以在 Parent 类中提供另一个 Foo()，该类除了调用其 base.Foo() 之外不执行任何操作。

Answer 5

如果您可以控制代码，最简单的方法是在父类中创建一个仅调用 base.Foo() 的受保护方法，并且您的子类 Foo 实现显式调用该方法

Answer 6

我们在一个大型项目中遇到过这种情况，其中派生方法是从不同位置调用的。由于变更管理和 QA 脚本不能被破坏，以及其他限制，在大型成熟项目中并不总是可能进行“剧烈”重构和类重构。此外，我们不想覆盖该方法并排除所有基本功能。在其他地方看到的大多数解决方案看起来有点笨拙，但是 Josh Jordan 关于如何调用的解决方案base.base 非常有用。

然而，我们遵循了下面的方法（我现在看到的方法与丹·阿布拉莫夫的提议非常相似）。

public class Base
{
    public virtual void Foo()
    {
        Console.WriteLine("Hello from Base");
    }
}

public class Derived : Base
{
    public override void Foo()
    {
        base.Foo();
        Console.WriteLine("Text 1");
        WriteText2Func();
        Console.WriteLine("Text 3");
    }

    protected virtual void WriteText2Func()
    {
        Console.WriteLine("Text 2");
    }
}

public class Special : Derived
{
    public override void WriteText2Func()
    {
        //WriteText2Func will write nothing when method Foo is called from class Special.
        //Also it can be modified to do something else.
    }
}   

Answer 7

所有这些强烈的意见...

有时使用 99% 的东西才有意义...

public class Base
{
  public virtual void Foo()
  {
   // Do something
  }
}

public class DerivedLevel1 : Base
{
  public override void Foo()
  {
    DerivedLevel1Foo();
  }
  protected void DerivedLevel1Foo()
  {
    // Do something
    base.Foo();
  }
}

public class DerivedLevel2 : DerivedLevel1
{
  public override void Foo()
  {
   DerivedLevel2Foo();
  }
  protected void DerviedLevel2Foo()
  {
    // Do something
    base.Foo();
  }
}

public class Special : Derived
{
  public override void Foo()
  {
    // Don't do DerivedLevel2Foo()
    base.DerivedLevel1Foo();
  }
}