Comment Glass lit les instanciations de méthodes génériques
Un appel de méthode générique se compile en un jeton MethodSpec accompagné d'un blob d'arguments de type distinct. Voici comment Glass.NET lit ce blob, substitue les marqueurs !!0 et décide quand le C# reconstitué a réellement besoin d'arguments de type explicites.
Appelez deux fois une méthode générique avec des types différents et le compilateur ne copie pas la méthode. Il émet le corps une seule fois, contre des marqueurs, et enregistre les arguments de type de chaque appel dans une structure minuscule et distincte. Un décompilateur qui ne comprend pas cette séparation perdra soit les arguments de type, soit les imprimera là où C# ne les aurait jamais écrits. Voici le mécanisme que Glass.NET utilise pour tout restituer exactement.
La vraie question
Considérez une méthode générique sur un type et les deux appels qui l’instancient :
using System;
static class Program
{
static T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) >= 0 ? a : b;
static void Main()
{
int m = Max(3, 7);
string s = Max("a", "b");
Console.WriteLine($"{m} {s}");
}
}
Il y a un seul Max dans l’assembly compilé. Son corps est écrit contre un paramètre de type, pas contre int ni string. Alors où sont passés le int et le string, et comment Glass les remet-il en place sans inventer des chevrons que le code source n’a jamais eus ?
Le corps est écrit une seule fois, contre des marqueurs
Décompilez la définition de la méthode et le paramètre générique apparaît sous la forme !!T partout où une T figurait dans le code source :
.method private hidebysig static !!T
Max<([System.Runtime]System.IComparable`1<!!T>) T>(!!T a, !!T b) cil managed
{
ldarga.s a
ldarg.1
constrained. !!T
callvirt instance int32 class [System.Runtime]System.IComparable`1<!!T>::CompareTo(!0)
ldc.i4.0
blt.s IL_000f
ldarg.0
ret
IL_000f: ldarg.1
ret
}
Deux espaces d’indices entrent ici en jeu, et les distinguer est tout l’enjeu. !!T (deux signes) est le paramètre générique de la méthode. Le !0 (un signe) à l’intérieur de IComparable 1<!!T>::CompareTo(!0)est le paramètre générique du **type** : l'unique paramètre deIComparable<>` lui-même. La CLI maintient les paramètres de méthode et de type dans des espaces de numérotation distincts précisément pour qu’une méthode générique sur un type générique n’ait jamais à lever l’ambiguïté entre l’indice 0 et l’indice 0.
Notez aussi le préfixe constrained. !!T : comme T peut être un type valeur, le compilateur ne peut pas savoir à la compilation si CompareTo nécessite un callvirt avec boxing. Le préfixe reporte cette décision au JIT, qui appelle directement la méthode du struct sans allocation. C’est une conséquence directe de where T : IComparable<T>, et Glass restitue la contrainte dans la signature de la méthode au lieu de l’abandonner.
Les arguments de type résident dans un MethodSpec
Le corps ne mentionne jamais int. Le point d’appel doit donc porter l’instanciation. Décompilez Main et chaque appel est une seule instruction contre un jeton MethodSpec :
ldc.i4.3
ldc.i4.7
call !!0 Program::Max<int32>(!!0, !!0)
...
ldstr "a"
ldstr "b"
call !!0 Program::Max<string>(!!0, !!0)
Les deux instructions pointent vers la même définition de méthode générique, mais via deux lignes MethodSpec distinctes (table de métadonnées 0x2B). Chaque ligne a deux colonnes : Method, une référence au Max générique, et Instantiation, un indice de blob. Le blob est une signature GENERICINST : un marqueur de convention d’appel d’un octet 0x0A, un nombre d’arguments, puis un type encodé par argument.
Pour Max<int32>, les octets du blob sont 0A 01 08 : convention d’appel GENERICINST (0x0A), un argument (0x01) et ELEMENT_TYPE_I4 (0x08). Pour Max<string>, l’octet final est 0x0E (ELEMENT_TYPE_STRING). Trois octets, c’est toute la différence entre les deux appels. Tout le reste — le corps, la liste des paramètres, le retour — est partagé.
Substituer, puis trancher sur les chevrons
Glass parcourt cela en deux temps. Il résout d’abord le MethodSpec : suivre Method jusqu’au générique ouvert Max<T>, lire Instantiation pour obtenir les arguments de type ordonnés [Int32], et lier !!0 à Int32. Cela suffit déjà à imprimer un Max<int>(3, 7) correct, quoique verbeux.
Le second temps est ce qui fait que la sortie se lit comme du code source. C# permet d’omettre les arguments de type lorsque le compilateur peut les inférer à partir des arguments ordinaires. Ici, les deux paramètres sont de type T et les deux arguments sont int, de sorte que l’inférence retrouve T = int d’elle-même, ce qui explique pourquoi le code source a écrit Max(3, 7) et non Max<int>(3, 7). Glass le reproduit : après substitution, il se demande si réexécuter l’inférence sur l’appel non annoté aboutirait à la même méthode fermée. Quand c’est le cas, les chevrons sont supprimés.
Quand l’inférence ne peut pas retrouver les arguments, Glass les conserve. Le cas classique est un argument de type qui n’apparaît qu’en position de retour :
static T Create<T>() where T : new() => new T();
var list = Create<List<int>>(); // aucun argument dont inférer
Create n’a pas de paramètres, donc rien au point d’appel ne contraint T. L’IL porte Create<class List1dans son MethodSpec, et Glass doit émettreCreate<List
Quand l’heuristique doit rester prudente
La récupération par inférence relève du jugement, et Glass privilégie la justesse à la concision. Si une méthode est surchargée de telle sorte que retirer les arguments de type ferait gagner une autre surcharge — ou rendrait l’appel ambigu —, Glass conserve les arguments explicites même si le code d’origine pouvait s’appuyer sur l’inférence. Le code décompilé est alors un peu plus verbeux que le source, mais il compile de façon démontrable vers le même MethodSpec. Ce compromis est délibéré : un décompilateur qui produit du code plus court se liant à la mauvaise méthode est pire qu’inutile.
L’autre limite honnête : les noms des arguments de type ont disparu. Un blob encode System.Int32, jamais le fait que la T inférée de l’auteur s’écrivait TKey dans une autre définition. Les noms des paramètres génériques sur les définitions survivent dans les métadonnées ; les types liés à eux à un point d’appel sont structurels, donc Glass imprime le type réel, int, qui est de toute façon ce que voit le runtime.
À retenir
Un appel générique en .NET est une jointure : un corps partagé contre des marqueurs, plus un MethodSpec par point d’appel dont le blob porte les types réels. Lisez le blob, liez !!0 jusqu’à !!n, gardez les paramètres de méthode et de type dans leurs espaces d’indices distincts, puis laissez l’inférence décider des chevrons — et l’appel décompilé se lit exactement comme le C# qui l’a produit. Glass.NET fait cela à chaque point d’appel générique, ce qui rend la sortie lisible au lieu d’un mur de chevrons. Consultez la vue IL et métadonnées pour inspecter vous-même les lignes MethodSpec.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.