Why does this generic method call the base class method, not the derived class method?

Question

For the following code:

class B
{
    public String G() { return "B.G()"; }
}

class D : B
{
    public String G() { return "D.G()"; }
}

class TestCompile
{
    private static String TestG<T>(T b) where T: B 
    {
        return b.G();
    }

    static void Main(string[] args)
    {
        TestG(new D());
    }
}

The result is B.G(), whereas the result of similar C++ code would be D.G().

Why is there this difference?

Answer 1

Use the override keyword:

class B
{
    public virtual String G() { return "B.G()"; }
}

class D : B
{
    public override String G() { return "D.G()"; }
}

Without the override keyword, the inherited method doesn't replace the base one.

Without override:

D obj = new D();
obj.G(); // "D.G()"
((B)obj).G(); // "B.G()"

With override:

D obj = new D();
obj.G(); // "D.G()"
((B)obj).G(); // "D.G()"

Answer 2

C# generics are compiled only once: at the time the generic is compiled. (Think about it: C# lets you use List<T> without seeing its implementation.) Here, it sees from the where T: B clause that the parameter is a B, so it calls B.G.

C++ templates are compiled each time they are invoked. When you type TestG<D>(), a brand new copy of TestG is compiled with T = D. At invocation time, the compiler sees that D has its own G method and calls it.

The C++ equivalent of the C# generic would be

template<typename T>
string TestG(T t)
{
    B& b = static_cast<B&>(t); // force `t` into a `B`
    return b.G();
}

The remarks of others regarding the use of virtual apply equally to C# and C++. I'm just explaining why C++ behaves differently from C#.

Answer 3

Becuase you've neglected to mark B.G as virtual, and D.G as override.

You got this compiler warning:

CS0108: 'D.G()' hides inherited member 'B.G()'. Use the new keyword if hiding was intended.

but you chose to ignore it. I would expect better from a C++ developer! :)