C#调用接口方法非虚拟实现

Question

我是C#新手，我不明白编译器为什么不抱怨这段代码。以下是类的层次结构：

interface IAble
{
    void f();
}

class AAble : IAble
{
    public void f()
    {
        Debug.Log("---->> A - Able");
    }
}

class BAble : AAble
{
    public void f()
    {
        Debug.Log("---->> B - Able");
    }
}

执行代码:

        IAble i = new BAble();
        i.f();

执行时<代码>----

当决定调用什么函数时--运行时还是编译时？如果我弄脏了一个新的< code>class CAble : IAble怎么办？

Answer 1

接口必须在直接继承自它的类中实现，而不是在派生类中实现。例如，此代码无法编译：

class AAble : IAble
{
    public void f() { ... }
}

class BAble : AAble
{
    // An attempt to explicitly implement interface in BAble through AAble class
    void IAble.f()
    {
        Console.WriteLine("---->> B - Able");
    }
}

当我们向上转换 BAble 以接口 IAble 时，将使用来自 AAble 的实现，因为它是编译预期中唯一实现该接口的类。

我们可以直接从接口继承，这将告诉编译器应该使用哪个接口实现：

class BAble : AAble, IAble
{
    // Now it compiles
    void IAble.f()
    {
        Console.WriteLine("---->> B - Able");
    }
}

输出:<代码>-

或者我们可以使用多态性。这将告诉编译器总是使用被覆盖的函数:

class AAble : IAble
{
    public virtual void f()
    {
        Debug.Log("---->> A - Able");
    }
}

class BAble : AAble, IAble
{
    public override void f()
    {
        Console.WriteLine("---->> B - Able");
    }
}

Answer 2

通常会有编译器警告，因为它隐藏了一个方法。但在C#中，对非虚拟函数这样做是合法的。当然，如果它是一个虚拟函数，那么显然该方法的B版本将运行。

因为你将它声明为一个可变量，并且它是非虚拟的，编译器将它读为一个可变量。如果它被声明为虚拟的，编译器将扫描继承的层次结构，并会看到它的实际类是BAble，它将运行BAble代码。

Answer 3

因为< code>AAble正在实现< code>IAble接口，所以它的< code>AAble.f被标记为类型< code>AAble的< code>IAble.f方法的实现。

< code>BAble.f只是隐藏了< code>AAble.f方法，而不是覆盖它。

IAble o = new BAble(); o.f(); // calls AAble.f
AAble o = new BAble(); o.f(); // calls AAble.f
BAble o = new BAble(); o.f(); // calls BAble.f
IAble o = new CAble(); o.f(); // calls CAble.f

决策是在编译时做出的：

// AAble.f in IL:
.method public final hidebysig newslot virtual 
    instance void f () cil managed 

// BAble.f in IL:
.method public hidebysig 
    instance void f () cil managed

接口实现在IL中被标记为虚拟，即使它在C#中没有被标记为虚拟。该方法在IL中也被标记为最终，如果该方法在C#中是虚拟，它就不会被标记为最终。