If the generic type argument (of either a calling class or calling method) is constrained with where T : Base the new method in T == Derived is not called, instead the method in Base is called.

Why is the type T ignored for method call even though it should be known before run time?

Update: BUT, when the constraint is using an interface like where T : IBase the method in Base class is called (not the method in interface, which is also impossible).
So that means the system actually is able to detect the types that far and go beyond the type constraint! Then why doesn't it go beyond the type constraint in case of class-typed constraint?
Does that mean that the method in Base class that implements the interface has implicit override keyword for the method?

What makes you think the interface-constrained one isn't calling IBase.Method? Try casting Obj to IBase and calling Method on it.
–
supercatMay 24 '12 at 16:38

1

Note that it makes a difference if you write instead public class Derived : Base, IBase, i.e. repeat the interface in the declaration of the derived class as well. That is called interface re-implementation. See the spec.
–
Jeppe Stig NielsenFeb 25 at 19:08

4 Answers
4

Except when using dynamic objects, C# always binds methods at compile time--even when using generics. Virtual method calls are bound to virtual method slots rather than to the implementing methods, so that when they are performed on derived-class objects they will be directed to the derived-class implementations; although the methods to which the slots point will be determined at run time, the binding to the slots occurs at compile time. If a derived-class method is declared new rather than override, code which is bound using the derived class will use the derived-class method, but code which is bound using the base class will use the base-class method.

To understand why this has to be the case, imagine if it weren't. What should happen if class Base declares a method int Foo(), and a class Derived:Base declares a new string Foo(). If a generic class with constraint T:Base tries to call method Foo on an object of type T, what should the return type of that method be?

Good point with the return type. (You can go on about method binding and virtual calls and slots, but some of us need an obvious breaking example to figure it out.)
–
RawlingMay 24 '12 at 16:07

@Rawling: The reason for discussing binding is to make clear that from the compiler's perspective, a generic type T constrained to Foo will in many ways behave more like a Foo than like the actual type that may be substituted for T at run-time. Generics in .net look like C++ templates, but they're fundamentally different.
–
supercatMay 24 '12 at 16:35

@supercat: Thanks, I guess if there weren't the issue of return types of new methods then the design could have been different. This seems to me the single cause of this design decision. Everything else about binding and not overloading etc is just stating the consequence. I also should have stated more clearly in the question that I know about the existence of overloading.
–
Roland PihlakasMay 24 '12 at 17:13

@RolandPihlakas: I doubt that's the single cause, actually. Even if one were to formulate rules that would allow the compiler to resolve all potential ambiguities posed by issues like that, having generics behave as though they are run-time bound would require that every generic method be recompiled for every combination of generic types used therein. That would seriously harm performance, while offering comparatively little benefit.
–
supercatMay 24 '12 at 17:59

@supercat: Yes, it would be inevitable that then multiple methods are being compiled for different generic types. But C++ does that too, isn't it? I was hoping that using generics enables me to get rid of virtual calls. Seems like this is not the case and the only performance-related use of generics is to avoid boxing value types. For classes, using generic argument types instead of interfaces (or base classes with virtual methods) can not offer performance benefits.
–
Roland PihlakasMay 24 '12 at 18:14

The new keyword simply hides the method instead of overloading it. The reason your non-generic CallMethod appears to work as expected is because the method signature expects a Derived instead of a Base.

Generics aren't really the culprit here. If you change the method signature to CallMethod(Base obj), you'll see the same "unexpected" behavior as the generic implementation and get the following output:

0
0
0
0
0
0
0
1

If you make Base.Method virtual and override it with Derived.Method like so: