Question

class Program
{
    static void Main(string[] args)
    {
        B foo = new B();
        foo.DoWork();
        Console.ReadLine();
    }
}

public class A
{
    public virtual void DoWork() { Console.WriteLine("A"); }
}
public class B : A
{
    public override void DoWork() { base.DoWork();  Console.WriteLine("B"); }
}

Why don’t I get StackOverflow exception? As I understand it, foo.DoWork() is called, then it calls base.DoWork(), which is virtual and overriden in class B.DoWork() method, which would repeat calling base.DoWork() again until stack is overflown. This overflow is easily achieved when using this instead of base (circular loop of calling self). What does prevent virtual function overriding in this case?

Answer 1

No, when you use base it doesn’t make a virtual call. The whole point is to be able to call the base implementation even if you’ve overridden it.

If you look in the generated IL, you’ll see it doesn’t use callvirt:

IL_0002:  call       instance void A::DoWork()

From section 7.6.8 of the C# 5 specification (emphasis mine):

When a base-access references a virtual function member (a method, property, or indexer), the determination of which function member to invoke at run-time (§7.5.4) is changed. The function member that is invoked is determined by finding the most derived implementation (§10.6.3) of the function member with respect to B (instead of with respect to the run-time type of this, as would be usual in a non-base access). Thus, within an override of a virtual function member, a base-access can be used to invoke the inherited implementation of the function member. If the function member referenced by a base-access is abstract, a binding-time error occurs.