为什么这个泛型方法调用基类方法，而不是派生类方法？

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 BG() , whereas the result of similar C++ code would be DG() .

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 BG .

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 BG as virtual , and DG as override .

You got this compiler warning:

CS0108: 'DG()' hides inherited member 'BG()'. Use the new keyword if hiding was intended.

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

Answer 4

It's because the parameter b is in a B type ref. if you cast b to D it'll call the function on D .