Question

I have this code snippet and I would like to know why is the output as written in comment below:

interface I {   
    void m1();
    void m2();      
    void m3();      
}

class A : I {
    public void m1() { Console.WriteLine("A.m1()"); }
        public virtual void m2() { Console.WriteLine("A.m2()"); }
        public virtual void m3() { Console.WriteLine("A.m3()"); }
}

class C : A, I {
    public new void m1() { Console.WriteLine("C.m1()"); }
    public override void m2() { Console.WriteLine("C.m2()"); }
    public new void m3() { Console.WriteLine("C.m3()"); }
}

------
C c = new C();

((I) ((A) c)).m1();  //"C.m1()"
((I) ((A) c)).m2();  //"C.m2()"
((I) ((A) c)).m3();  //"C.m3()"

One original guess of what the output shoud be was:

A.m1();
C.m2();
A.m3();

Answer 1

All these type-casts are redundant and I’m pretty sure they get optimized away by the compiler.

Here’s what I mean. (A) c is redundant since C is A, so we’re left just with (I)c, which is redundant as well, since C implements I. Thus, we have just an instance of C class, for which the compiler applies normal resolution rules.

EDIT

Turns out, I was completely wrong. This document describes what happens:

Interface mapping for a class or struct C locates an implementation for each member of each interface specified in the base class list of C. The implementation of a particular interface member I.M, where I is the interface in which the member M is declared, is determined by examining each class or struct S, starting with C and repeating for each successive base class of C, until a match is located:

• If S contains a declaration of an explicit interface member implementation that matches I and M, then this member is the implementation of I.M.
• Otherwise, if S contains a declaration of a non-static public member that matches M, then this member is the implementation of I.M.