自动调用基方法

如果您不想显式调用它,请确保 A.Fun() template method pattern :

class A
{
    public void Fun()
    {
        Console.Write("Class A!");
        FunProtected();
    }

    protected virtual void FunProtected()
    {
    }
}

class B : A
{
    protected override void FunProtected()
    {
        Console.Write("Class B!");
    }
}

new A().Fun() -> "Class A!"
new B().Fun() -> "Class A! Class B!"

如果你想要这样的行为,你需要改变平台/语言。.NET不会自动调用基方法。你需要明确地称呼它。你的方法也需要 virtual

class A
{
    public virtual void Fun()
    {
        Console.Write("Class A!");
    }
}

class B : A
{
    public override void Fun()
    {
        // call the base method which will print Class A!
        base.Fun(); 
        Console.Write("Class B!");
    }
}

现在,当你这样做时:

B b = new B();
b.Fun();

你会得到所需的结果。

interface IFun
{
    void Fun();
}

abstract class A : IFun
{
    void IFun.Fun()
    {
        Console.Write("Class A!");
        Fun();
    }
    protected abstract void Fun();
}

class B : A
{
    protected override void Fun()
    {
        Console.Write("Class B!");
    }
}

IFun b = new B();
b.Fun();

如果对象引用是IFun,则此操作有效。

作为参考,您可以使用一个包装器模式,将a放在B中 例子!

interface IFunClass {
    void Fun();
}

class A : IFunClass {
    public void IFunClass.Fun() {
        Console.Write("Class A!");
    }
}

class B : IFunClass {
    public B(IFunClass f) {
        this.m_SomethingFun = f;
    }

    public void IFunClass.Fun() {

        this.m_SomethingFun.Fun();

        Console.Write("Class B!");
    }

    private IFunClass m_SomethingFun;
}

A a = new A();
B b = new B(a);

b.Fun() // will call a.Fun() first inside b.Fun()