Skip to content
← Tous les articles
· Delta1 Labs MetadataGlass

Comment Glass reconstruit les noms de types génériques imbriqués

Le nom qu'un type générique porte dans les métadonnées est encodé avec un accent grave et un nombre, et ce nombre ne compte que les paramètres que le type ajoute pour lui-même : un type imbriqué hérite des paramètres de son type englobant mais ne les compte pas dans son nom. Cet article lit l'encodage réel, montre pourquoi le vecteur plat d'arguments génériques doit être réparti entre les niveaux d'imbrication, et explique comment Glass.NET reconvertit Outer`2/Inner`1 en Outer<int, string>.Inner<bool>.

Décompilez un type imbriqué dans un type générique et le nom que vous récupérez — Outer<int, string>.Inner<bool> — ne ressemble en rien au nom stocké sur disque. Les métadonnées contiennent Inner1`, avec un accent grave et un nombre, et ce nombre n’est pas trois, bien que trois paramètres de type soient dans la portée du type. L’écart entre ces deux écritures est l’une des petites choses précises qu’un décompilateur doit obtenir exactement, car se tromper produit du C# qui ne compile pas.

La vraie question

Le nom d’un type générique dans les métadonnées .NET porte un mangling : List1, Dictionary2, Func4`. L’accent grave et le nombre encodent l’arité générique du type. Cette règle est simple jusqu’à ce que les types s’imbriquent. Un type imbriqué dans un type générique peut utiliser les paramètres de l’englobant comme s’ils étaient les siens — mais son nom ne les compte pas. Alors, où vit l’image complète, et comment un lecteur passe-t-il d’un nom avec mangling plus une liste plate d’arguments de type au nom générique pleinement qualifié qu’un développeur reconnaîtrait ?

L’arité compte ce que le type ajoute, pas ce qu’il possède

Prenez un type générique avec un type générique imbriqué à l’intérieur :

public class Outer<TKey, TValue>
{
    public class Inner<TState>
    {
        public TValue Get(TKey key, TState state) => default;
    }
}

Inner utilise trois paramètres de type — TKey et TValue d’Outer, plus son propre TState. Mais son nom de métadonnées ne le reflète pas. Voici comment les deux types sont stockés, rendus tels que Glass les affiche dans la vue IL :

.class public auto ansi beforefieldinit Outer`2<TKey, TValue>
       extends [System.Runtime]System.Object
{
  .class auto ansi nested public beforefieldinit Inner`1<TState>
         extends [System.Runtime]System.Object
  {
    // inside Inner the parameter index space is [TKey=!0, TValue=!1, TState=!2]
    .method public hidebysig instance !1 Get(!0 key, !2 state) cil managed
    {
      // returns TValue (!1), takes TKey (!0) and TState (!2)
    }
  }
}

Outer est Outer2: il ajoute deux paramètres.InnerestInner1 : il en ajoute un. Le 1, c’est TState seul. TKey et TValue sont hérités, et le nom ne compte pas les paramètres hérités.

Et pourtant, regardez la signature de la méthode. Get renvoie TValue et c’est encodé en !1 : index de paramètre générique 1. Ses arguments sont !0 (TKey) et !2 (TState). L’espace d’index à l’intérieur d’Inner va 0, 1, 2 à travers les trois paramètres, englobant d’abord. Donc Inner a une arité de trois pour les signatures, mais un nom qui dit un. Ce n’est pas une contradiction : ce sont deux nombres différents pour deux tâches différentes.

Les deux nombres, dans les tables

Le nom vit dans le heap #Strings sous forme du texte littéral Inner1. Ce n'est qu'une chaîne ; elle ne porte aucune information sur ce dans quoi Inner est imbriqué. L'imbrication est un fait à part, stocké dans la table **NestedClass** : une ligne reliant le TypeDef d'Inner au TypeDef d'Outer`. Parcourez cette table et vous apprenez la chaîne des englobants ; lisez le nom et vous apprenez l’arité propre. Aucun ne connaît l’autre.

Le troisième nombre est dans la table GenericParam. Chaque paramètre générique dans la portée d’un type obtient une ligne détenue par ce type, numérotée à partir de zéro. Pour Inner, la table contient trois lignes — TKey (0), TValue (1), TState (2) — : les paramètres de l’englobant re-listés d’abord, puis les propres du type. C’est pourquoi !0 se résout en TKey à l’intérieur des corps de méthode d’Inner. Ainsi le même type imbriqué porte une arité propre de un dans son nom et un compte total de paramètres de trois dans GenericParam. Un décompilateur doit garder les deux à l’esprit en même temps.

Répartir le vecteur plat d’arguments

Maintenant, construisez le type et le vrai travail apparaît :

Outer<int, string>.Inner<bool> x = new();

Le CLR encode Outer<int, string>.Inner<bool> comme une unique signature GenericInst : la référence au type le plus interne, un compte d’arguments génériques de 3 et un vecteur plat de trois arguments — int, string, bool. Aucun regroupement dans les octets. Rien ne dit qu’int et string appartiennent à Outer et bool à Inner. La signature est plate précisément parce que l’espace d’index des paramètres est plat.

Pour imprimer un nom C# valide, Glass doit regrouper ce vecteur plat entre les niveaux d’imbrication, et la seule chose qui lui indique où faire les coupes est l’arité propre de chaque niveau — le nombre d’accent grave qu’il a retiré du nom. Outer2prend les deux premiers arguments ;Inner1 prend le suivant. Consommez-les dans l’ordre englobant-vers-imbriqué et le vecteur est partitionné exactement.

Ce que stockent les métadonnéesOuter`2 / Inner`1nom + ligne NestedClassGenericInst argc=3vecteur plat, sans regroupementVecteur plat d'arguments de typeint [0]string [1]bool [2]Répartition selon l'arité propre de chaque accentOuter`2 → prend [0], [1]arité propre 2Inner`1 → prend [2]arité propre 1Outer<int, string>.Inner<bool>SéparateursC# . (source)réflexion +ILAsm /
Le vecteur d'arguments est plat ; la seule chose qui indique où le couper est l'arité propre de chaque niveau, lue depuis l'accent grave. Glass découpe d'englobant à imbriqué et remplit les chevrons de chaque niveau.

Le regroupement doit être correct, sinon la sortie est inexploitable. Si Glass donnait naïvement les trois arguments au nom le plus interne, il rendrait Inner<int, string, bool> : un type qui n’existe pas. S’il donnait le premier argument à Outer et le reste à Inner, il rendrait Outer<int>.Inner<string> et laisserait tomber bool en silence. Les arités d’accent grave sont les clés de partition, et elles sont la raison même pour laquelle le mangling de noms porte le compte propre plutôt que le total : le compte propre est exactement ce dont vous avez besoin pour parcourir le vecteur plat niveau par niveau.

Les séparateurs sont tous de l’affichage

Encore une chose que les octets ne stockent pas : le séparateur entre niveaux. Le Type.FullName de la réflexion joint les types imbriqués avec + (App.Outer2+Inner1), ILAsm utilise / (Outer2/Inner1) et le code source C# utilise . (Outer.Inner). Les trois sont rendus par-dessus la même ligne NestedClass. Glass émet . dans sa sortie C# et préserve + ou / dans les vues token et IL, de sorte que le nom que vous lisez correspond toujours à la surface sur laquelle vous le lisez.

Le lire depuis la CLI

Pas besoin de l’interface pour voir la répartition en action. Les ID de membre des commentaires de documentation conservent la forme avec mangling et accent grave, c’est donc ainsi qu’on adresse un type générique imbriqué :

$ glass export ./App.dll --member "T:App.Outer`2.Inner`1" --il

La vue IL montre Outer2et l'imbriquéInner1 avec les index de paramètre !0/!1/!2 intacts. Retirez --il et le C# reconstruit imprime Outer<TKey, TValue>.Inner<TState> pour la définition ouverte, avec les accents graves retirés et les chevrons de chaque niveau remplis depuis sa part de la liste de paramètres. Pointez Glass vers un site d’appel qui construit le type fermé et la même mécanique rend Outer<int, string>.Inner<bool>.

Mises en garde et là où ça se complique

Quelques limites honnêtes. L’arité de l’accent grave est une convention de C#, pas une règle du CLR : un langage autre que C#, ou de l’IL écrit à la main, peut émettre un type générique dont le nom ne porte aucun accent grave, ou un compte d’accent grave en désaccord avec ses lignes GenericParam. Dans ce cas, Glass fait confiance à la table GenericParam et à la chaîne NestedClass, pas à la chaîne de texte, car les tables sont ce à quoi le runtime se lie réellement. Et les chaînes profondément imbriquées — un générique imbriqué dans un générique imbriqué dans un générique — ne font qu’étendre la même répartition : lisez l’arité propre de chaque niveau, consommez autant d’arguments, récursez. L’arithmétique est simple ; la discipline consiste à ne jamais confondre l’arité propre avec l’arité totale, car les métadonnées vous remettent les deux et les utilisent pour des choses différentes.

À retenir

Un type générique imbriqué est stocké comme trois faits séparés qui ne se touchent jamais : un nom avec mangling dans le heap #Strings qui ne compte que les paramètres que le type ajoute, une ligne NestedClass qui enregistre ce dans quoi il est imbriqué, et une liste GenericParam qui contient chaque paramètre dans la portée. Le construire en produit un quatrième : un vecteur plat et non regroupé d’arguments de type. Glass.NET lit les quatre, parcourt la chaîne des englobants, découpe le vecteur plat selon l’arité propre de chaque niveau et joint le résultat avec le séparateur adapté à la vue dans laquelle vous êtes. C’est un petit coin des métadonnées, et c’est pourquoi bien décompiler un nom générique imbriqué signifie lire les tables, pas faire confiance à la chaîne de texte. Récupérez la version gratuite sur la page de téléchargement de Glass.NET et ouvrez la vue IL sur le prochain Outer<...>.Inner<...> que vous devez lire.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.