¿Cómo se instancian los métodos genéricos en C#?

Question

Supongamos que tengo un método genérico como:

void Fun<T>(FunArg arg) {} 

son this.Fun<Feature> y this.Fun<Category> diferentes instancias del método genérico?

En general, ¿cómo se instancia el método genérico? ¿Diferente argumento genérico produce un método diferente o el mismo método junto con diferentes metadatos que se usan en tiempo de ejecución?

Responda su respuesta con alguna cita de la especificación del idioma.

Además, supongo que sí los siguientes:

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

luego más tarde,

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

¿El lineX deshacer lo que hice en line1? ¿O depende de algo más también?

Answer 1

Depende de los tipos implicados.

Para todos los tipos de referencia (es decir. clases), uno método será compilados JIT para manejar todas.

Para todos los tipos de valores (es decir. estructuras), uno método será compilados JIT por tipo.

Así que la información en la pregunta no es lo suficientemente detallada para responder, si Feature y Category son tipos de referencia, entonces sí, un método estará JITted para ellos. Si uno de ellos, o ambos, son tipos de valor, un método por tipo de valor estará JITted.

Tenga en cuenta mi uso de la palabra JITted aquí. En el ensamblado compilado, solo habrá un método, pero en tiempo de ejecución, JITter creará implementaciones reales de los métodos genéricos de acuerdo con las reglas anteriores.

Pop Quiz: ¿Qué ocurre si utiliza NGEN en un ensamblaje con tipos/métodos genéricos? (Pista: not what you think)

Answer 2

Sí, se convertirán en dos métodos separados.

Answer 3

Todos ellos comparten una definición de método , pero en tiempo de ejecución que son diferentes MethodInfo - porque los argumentos de tipo genérico definen un método genérico.

Apoyando la ilustración:

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 

A nivel JIT, es más complejo; cualquier parámetro de tipo de referencia tendrá una implementación, como referencia es una referencia es una referencia (teniendo en cuenta que todos los tales T deben cumplir con cualquier restricción de antemano).Si hay valor-tipo T, entonces cada combinación de argumentos de tipo genérico obtiene una implementación separada en tiempo de ejecución, ya que cada uno requiere una implementación final diferente.