Question

Consider this code sample:

public abstract class Parent
{
    public int val;
    public Parent()
    {
        val = 0;
    }
    public virtual void foo()
    {
        inc();
    }

    public virtual void inc()
    {
        val = val + 10;
    }
}

public class Child : Parent
{
    public override void foo()
    {
        base.foo();
    }

    public override void inc()
    {
        val++;
    }
}

static void Main(string[] args)
{
    Parent p = new Child();
    Console.WriteLine("p.val = " + p.val);  //Output: p.val = 0
    p.foo();
    Console.WriteLine("P.val = " + p.val);  //Output: p.val = 1
}

I am assuming the inc() of the Parent class did not get called because {this} pointer is actually pointing to a Child object so the Child’s version of inc() will be called from the Parent object’s function foo(). Is there a way to force the Parent’s function foo() to always call parent’s function inc() Like you could in C++ with :: operator?

Answer 1

You’re over-thinking the problem.

• If you want non-virtual dispatch then don’t make the methods virtual in the first place.

• If you want both virtual and non-virtual dispatch then make two methods, one virtual and one static

For example:

class Base
{
    protected static void NonVirtualFoo(Base b)
    {
        // Whatever
    }
    public virtual void Foo()
    {
        Base.NonVirtualFoo(this);
    }
}

class Derived : Base
{
    protected new static void NonVirtualFoo(Derived d)
    {
        // Whatever
    }
    public override void Foo()
    {
        Derived.NonVirtualFoo(this);
        Base.NonVirtualFoo(this);
    }
}

Use the right tool for the job. If you want virtual dispatch then call a virtual method. If you want static dispatch then call a static method. Don’t try to take a hammer to a virtual method and make it statically dispatched; that’s working against the entire purpose of the tool.