泛型方法如何在C＃中实例化？

Question

Suppose I've a generic method as:

void Fun<T>(FunArg arg) {}

Are this.Fun<Feature> and this.Fun<Category> different instantiations of the generic method?

In general, how does the generic method get instantiated? Different generic argument produces different method, or same method along with different metadata which is used at runtime?

Please support your answer with some quote(s) from the language specification.

Also, suppose I did these:

client.SomeEvent += this.Fun<Feature>;   //line1
client.SomeEvent += this.Fun<Category>;  //line2
client.SomeEvent += this.Fun<Result>;    //line3

then later on,

client.SomeEvent -= this.Fun<Feature>;   //lineX

Does the lineX undo the thing which I did at line1 ? Or it depends on somethig else also?

Answer 1

They all share a method definition , but at runtime they are different MethodInfo - because the generic type arguments define a generic method.

Supporting illustration:

    Action<FunArg> a1 = Fun<X>;
    Action<FunArg> a2 = Fun<Y>;
    Action<FunArg> a3 = Fun<Y>;
    Console.WriteLine(a1.Method == a2.Method); // false
    Console.WriteLine(a3.Method == a2.Method); // true

At the JIT level, it is more complex; any reference-type parameters will share an implementation, as a reference is a reference is a reference (noting that all such T must satisfy any constraints in advance). If there are value-type T , then every combination of generic type arguments gets a separate implementation at runtime, since each requires a different final implementation.

Answer 2

It depends on the types involved.

For all the reference types (ie. classes ), one method will be JITted to handle them all.

For all the value types (ie. structs ), one method per type will be JITted.

So the information in the question is not detailed enough to answer, if Feature and Category are reference types, then yes, one method will be JITted for them. If one of them, or both, are value types, one method per value type will be JITted.

Note my use of the word JITted here. In the assembly compiled, there will be only one method, but at runtime, the JITter will create actual implementations of the generic methods according to the above rules.

Pop Quiz : What happens if you use NGEN on an assembly with generic types/methods? (hint: not what you think )

Answer 3

是的，它们将成为两种不同的方法。