c#中的非虚方法、静态绑定和接口

我理解非虚方法是静态绑定的，这意味着，据我所知，在编译时本身就知道哪个对象将调用哪个方法。这个决定是基于对象的静态类型做出的。让我困惑的是接口(而不是类)和静态绑定。

考虑下面的代码，

public interface IA
{
    void f();
}
public class A : IA
{
    public void f() {  Console.WriteLine("A.f()"); }
}
public class B : A 
{
    public new void f() {  Console.WriteLine("B.f()"); }
}
B b = new B();
b.f();  //calls B.f()     //Line 1
IA ia = b as IA;
ia.f(); //calls A.f()     //Line 2

演示代码:http://ideone.com/JOVmi

我理解Line 1。编译器可以知道b.f()将调用B.f()，因为它知道b的静态类型是B。

但是编译器如何在编译时决定 ia.f()将调用A.f() ?对象ia的静态类型是什么?不是IA吗?但那是一个接口，没有任何f()的定义。那它是怎么起作用的?

为了使情况更令人费解，让我们考虑以下static方法:

static void g(IA ia)
{
   ia.f(); //What will it call? There can be too many classes implementing IA!
}

正如注释所说，可能有太多实现接口IA的类，那么编译如何静态地决定ia.f()将调用哪个方法?我的意思是，如果我有一个定义为:

的类

public class C : A, IA 
{
    public new void f() { Console.WriteLine("C.f()"); }
}

如您所见，C与B不同，除了从A派生之外，还实现了IA。这意味着，我们在这里有一个不同的行为:

g(new B()); //inside g(): ia.f() calls A.f() as before!
g(new C()); //inside g(): ia.f() doesn't calls A.f(), rather it calls C.f()

演示代码:http://ideone.com/awCor

我该如何理解所有这些变化，特别是接口和静态绑定是如何一起工作的?

And few more (ideone):

C c = new C();
c.f(); //calls C.f()
IA ia = c as IA;
ia.f(); //calls C.f()
A a = c as A;
a.f(); //doesn't call C.f() - instead calls A.f()
IA iaa = a as IA;
iaa.f(); //calls C.f() - not A.f()

请帮助我理解所有这些，以及静态绑定是如何由c#编译器完成的。

    .locals init (
            class B   V_0,
            class IA  V_1)
    IL_0000:  newobj instance void class B::'.ctor'()
    IL_0005:  stloc.0
    IL_0006:  ldloc.0
    IL_0007:  callvirt instance void class B::f()
    IL_000c:  ldloc.0
    IL_000d:  stloc.1
    IL_000e:  ldloc.1
    IL_000f:  callvirt instance void class IA::f()
    IL_0014:  ret