Question

有什么方法可以从基中调用重写方法的主体吗？例如：

public class BaseClass
{
    public virtual void DoMe()
    {
        using(new UseSomething())
        {
           //invoke the derived method body
        }//end using
    }//end do me 
 }//end base class

public class Der : BaseClass
{
    public override void DoMe()
    {
        Console.WriteLine("der do me");
    }//end do me
}//end der class

Answer 1

也许可以选择使用“模板方法”模式。

这里有一个很好的描述： https://www.youtube.com/watch?v=7ocpwK9uesw

因此，您可以如下定义基本抽象类；

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

    public abstract void AfterMe();

    public virtual void DoMe()
    {
       Console.WriteLine("Executing DoMe of BaseClass");
    }

    public void ExecuteMe()
    {
        BeforeMe();
        DoMe();
        AfterMe();
    }
}

然后您就拥有具体的课程

public class Der: BaseClass
{
    public override void BeforeMe()
    {
       Console.WriteLine("Executing BeforeMe of Der class");
    }

    public override void AfterMe()
    {
       Console.WriteLine("Executing AfterMe of Der class");
    }
}

然后按如下所示使用它

Der myDer = new Der();
myDer.ExecuteMe();

Answer 2

显然，您想从基类（using(new UseSomething())）中建立的上下文中调用某些逻辑的派生实现。

这强烈暗示了必须继承基类，否则就没有意义。这自然导致将其标记为abstract，从而自然解决了您的问题：

public abstract class BaseClass
{
    public void DoMe()
    {
        using (new UseSomething())
        {
            ActualDoMe();
        }
    }

    protected abstract void ActualDoMe();
}

public class Der : BaseClass
{
    protected override void ActualDoMe()
    {
        Console.WriteLine("der do me");
    }
}

Answer 3

不，这不起作用，因为Der.DoMe可能会调用BaseClass.DoMe（通过写base.DoMe()）。您不能向下跳下继承链，只能以相反的顺序进行。实际上，您的基类不应该对派生类中的virtual方法是否被实际覆盖做出任何假设。如果Der不覆盖该方法，您会有什么期望？无论如何，这并不意味着您无法在BaseClass.DoMe甚至virtual内的abstract内呼叫另一个成员，从而导致对Der.AnotherMethod的呼叫。

如果您想要的是可能的，这将导致无休止的递归，因为base.DoMe随后将再次调用Der.DoMe，而后者将调用base.DoMe，依此类推：

public class BaseClass
{
    public virtual void DoMe()
    {
        using(new UseSomething())
        {
            //invoke the derived method body
        }
    }
}
public class Der : BaseClass
{
    public override void DoMe()
    {
        base.DoMe(); // this would call the base-method which will then call this method again and so on...
    }
}

您应该重新考虑您的设计。不要从您的基础调用派生的方法，而是从您的派生调用：

public class BaseClass
{
    public virtual void DoMe()
    {
        using(new UseSomething())
        {
           // do the real base-stuff
        }
    }
}    
public class Der : BaseClass
{
    public override void DoMe()
    {
        base.DoMe(); // now there´s no endless recursion
        // some additional stuff
    }
}

另外创建一个您从BaseClass.DoMe呼叫的成员：

public class BaseClass
{
    public virtual void DoSomething() {  }
    public virtual void DoMe()
    {
        using(new UseSomething())
        {
           DoSomething();  // this will call the most derived member, in our case Der.DoSomething
        }
    }
}    
public class Der : BaseClass
{
    public override void DoSomething()
    {
        // some additional stuff
    }
    public override void DoMe()
    {
        Console.WriteLine("Der do me");
    }
}

从基础方法调用派生方法的主体

3 个答案: