Skip to content
← Alle Beiträge
· Delta1 Labs MetadataGlass

Wie Glass Namen verschachtelter generischer Typen rekonstruiert

Der Name, den ein generischer Typ in den Metadaten trägt, ist mit einem Backtick und einer Zahl kodiert, und diese Zahl zählt nur die Parameter, die der Typ für sich selbst hinzufügt – ein verschachtelter Typ erbt die Parameter seines umschließenden Typs, zählt sie aber nicht in seinem Namen. Dieser Beitrag liest die echte Kodierung, zeigt, warum der flache Vektor generischer Argumente auf die Verschachtelungsebenen verteilt werden muss, und erklärt, wie Glass.NET Outer`2/Inner`1 zurück in Outer<int, string>.Inner<bool> verwandelt.

Dekompiliere einen Typ, der in einem generischen Typ verschachtelt ist, und der Name, den du zurückbekommst – Outer<int, string>.Inner<bool> – sieht ganz anders aus als der auf der Festplatte gespeicherte Name. Die Metadaten enthalten Inner1`, mit einem Backtick und einer Zahl, und diese Zahl ist nicht drei, obwohl drei Typparameter im Gültigkeitsbereich des Typs liegen. Die Lücke zwischen diesen beiden Schreibweisen ist eines der kleinen, präzisen Dinge, die ein Dekompilierer exakt richtig machen muss, denn ein Fehler erzeugt C#, das nicht kompiliert.

Die eigentliche Frage

Der Name eines generischen Typs in .NET-Metadaten trägt ein Mangling: List1, Dictionary2, Func4`. Der Backtick und die Zahl kodieren die generische Arität des Typs. Diese Regel ist einfach, bis Typen verschachtelt werden. Ein in einem generischen Typ verschachtelter Typ kann die Parameter des umschließenden Typs verwenden, als wären es seine eigenen – aber sein Name zählt sie nicht. Wo lebt also das vollständige Bild, und wie gelangt ein Leser von einem Namen mit Mangling plus einer flachen Liste von Typargumenten zurück zum voll qualifizierten generischen Namen, den ein Entwickler erkennen würde?

Die Arität zählt, was der Typ hinzufügt, nicht was er hat

Nimm einen generischen Typ mit einem darin verschachtelten generischen Typ:

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

Inner verwendet drei Typparameter – TKey und TValue aus Outer plus sein eigenes TState. Aber sein Metadatenname spiegelt das nicht wider. So werden die beiden Typen gespeichert, gerendert so, wie Glass sie in der IL-Ansicht zeigt:

.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 ist Outer2– es fügt zwei Parameter hinzu.InneristInner1 – es fügt einen hinzu. Die 1 ist TState allein. TKey und TValue werden geerbt, und der Name zählt geerbte Parameter nicht.

Und doch: Sieh dir die Methodensignatur an. Get gibt TValue zurück, und das ist als !1 kodiert – generischer Parameterindex 1. Seine Argumente sind !0 (TKey) und !2 (TState). Der Indexraum innerhalb von Inner läuft 0, 1, 2 über alle drei Parameter, umschließend zuerst. Inner hat also eine Arität von drei für Signaturzwecke, aber einen Namen, der eins sagt. Das ist kein Widerspruch – es sind zwei verschiedene Zahlen für zwei verschiedene Aufgaben.

Die zwei Zahlen, in den Tabellen

Der Name lebt im #Strings-Heap als der wörtliche Text Inner1. Es ist nur eine Zeichenkette; sie trägt keine Information darüber, worin Innerverschachtelt ist. Die Verschachtelung ist eine eigene Tatsache, gespeichert in der Tabelle **NestedClass** – eine Zeile, die den TypeDef vonInnermit dem TypeDef vonOuter` verknüpft. Durchlaufe diese Tabelle, und du erfährst die Kette der umschließenden Typen; lies den Namen, und du erfährst die Eigen-Arität. Keiner weiß vom anderen.

Die dritte Zahl steht in der Tabelle GenericParam. Jeder generische Parameter im Gültigkeitsbereich eines Typs erhält eine Zeile, die diesem Typ gehört, von null an nummeriert. Für Inner enthält die Tabelle drei Zeilen – TKey (0), TValue (1), TState (2) –: die Parameter des umschließenden Typs zuerst erneut aufgelistet, dann die eigenen des Typs. Deshalb löst sich !0 innerhalb der Methodenrümpfe von Inner zu TKey auf. So trägt derselbe verschachtelte Typ eine Eigen-Arität von eins in seinem Namen und eine Gesamtparameterzahl von drei in GenericParam. Ein Dekompilierer muss beide gleichzeitig im Kopf behalten.

Den flachen Argumentvektor aufteilen

Konstruiere nun den Typ, und die eigentliche Arbeit erscheint:

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

Die CLR kodiert Outer<int, string>.Inner<bool> als eine einzige GenericInst-Signatur: die innerste Typreferenz, eine Anzahl generischer Argumente von 3 und einen flachen Vektor von drei Argumenten – int, string, bool. Keine Gruppierung in den Bytes. Nichts sagt, dass int und string zu Outer gehören und bool zu Inner. Die Signatur ist flach, gerade weil der Parameter-Indexraum flach ist.

Um einen gültigen C#-Namen auszugeben, muss Glass diesen flachen Vektor auf die Verschachtelungsebenen umgruppieren, und das Einzige, was ihm sagt, wo die Schnitte liegen, ist die Eigen-Arität jeder Ebene – die Backtick-Zahl, die es vom Namen abgetrennt hat. Outer2nimmt die ersten beiden Argumente;Inner1 nimmt das nächste. Verbrauche sie in der Reihenfolge umschließend-zu-verschachtelt, und der Vektor ist exakt partitioniert.

Was die Metadaten speichernOuter`2 / Inner`1Name + NestedClass-ZeileGenericInst argc=3flacher Vektor, ohne GruppierungFlacher Typargument-Vektorint [0]string [1]bool [2]Aufteilung nach Eigen-Arität jedes BackticksOuter`2 → nimmt [0], [1]Eigen-Arität 2Inner`1 → nimmt [2]Eigen-Arität 1Outer<int, string>.Inner<bool>TrennerC# . (Quelle)Reflection +ILAsm /
Der Argumentvektor ist flach; das Einzige, was sagt, wo er zu schneiden ist, ist die Eigen-Arität jeder Ebene, gelesen aus dem Backtick. Glass teilt von umschließend zu verschachtelt und füllt die spitzen Klammern jeder Ebene.

Die Gruppierung muss stimmen, sonst ist die Ausgabe unbrauchbar. Gäbe Glass naiv alle drei Argumente dem innersten Namen, würde es Inner<int, string, bool> rendern – einen Typ, den es nicht gibt. Gäbe es das erste Argument Outer und den Rest Inner, würde es Outer<int>.Inner<string> rendern und bool stillschweigend fallen lassen. Die Backtick-Aritäten sind die Partitionsschlüssel, und sie sind genau der Grund, warum das Namens-Mangling die Eigen-Zahl statt der Gesamtzahl trägt: Die Eigen-Zahl ist genau das, was du brauchst, um den flachen Vektor Ebene für Ebene zu durchlaufen.

Die Trenner sind alle Anzeige

Noch etwas, das die Bytes nicht speichern: den Trenner zwischen den Ebenen. Das Type.FullName der Reflection verbindet verschachtelte Typen mit + (App.Outer2+Inner1), ILAsm verwendet / (Outer2/Inner1) und C#-Quellcode verwendet . (Outer.Inner). Alle drei werden über dieselbe NestedClass-Zeile gerendert. Glass gibt . in seiner C#-Ausgabe aus und bewahrt + oder / in den Token- und IL-Ansichten, sodass der Name, den du liest, immer zu der Oberfläche passt, auf der du ihn liest.

Es über die CLI lesen

Du brauchst die Oberfläche nicht, um die Aufteilung in Aktion zu sehen. Member-IDs aus Dokumentationskommentaren behalten die Form mit Mangling und Backtick, und so adressiert man einen verschachtelten generischen Typ:

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

Die IL-Ansicht zeigt Outer2und das verschachtelteInner1 mit den Parameterindizes !0/!1/!2 intakt. Lass --il weg, und das rekonstruierte C# gibt Outer<TKey, TValue>.Inner<TState> für die offene Definition aus, mit entfernten Backticks und den spitzen Klammern jeder Ebene, gefüllt aus ihrem Anteil an der Parameterliste. Richte Glass auf eine Aufrufstelle, die den geschlossenen Typ konstruiert, und dieselbe Mechanik rendert Outer<int, string>.Inner<bool>.

Vorbehalte und wo es schwierig wird

Ein paar ehrliche Grenzen. Die Backtick-Arität ist eine Konvention von C#, keine CLR-Regel: Eine andere Sprache als C# oder handgeschriebenes IL kann einen generischen Typ ausgeben, dessen Name überhaupt keinen Backtick trägt oder eine Backtick-Zahl, die nicht zu seinen GenericParam-Zeilen passt. Wenn das passiert, vertraut Glass der GenericParam-Tabelle und der NestedClass-Kette, nicht der Zeichenkette, denn die Tabellen sind das, woran die Laufzeit tatsächlich bindet. Und tief verschachtelte Ketten – ein Generikum, verschachtelt in einem Generikum, verschachtelt in einem Generikum – erweitern nur dieselbe Aufteilung: Lies die Eigen-Arität jeder Ebene, verbrauche so viele Argumente, rekursiere. Die Arithmetik ist einfach; die Disziplin besteht darin, Eigen-Arität niemals mit Gesamt-Arität zu verwechseln, denn die Metadaten reichen dir beide und verwenden sie für verschiedene Dinge.

Fazit

Ein verschachtelter generischer Typ wird als drei getrennte Fakten gespeichert, die sich nie berühren: ein Name mit Mangling im #Strings-Heap, der nur die Parameter zählt, die der Typ hinzufügt, eine NestedClass-Zeile, die festhält, worin er verschachtelt ist, und eine GenericParam-Liste, die jeden Parameter im Gültigkeitsbereich enthält. Ihn zu konstruieren erzeugt einen vierten: einen flachen, ungruppierten Vektor von Typargumenten. Glass.NET liest alle vier, durchläuft die Kette der umschließenden Typen, teilt den flachen Vektor nach der Eigen-Arität jeder Ebene auf und verbindet das Ergebnis mit dem passenden Trenner für die Ansicht, in der du bist. Es ist eine kleine Ecke der Metadaten, und es ist der Grund, warum das gute Dekompilieren eines verschachtelten generischen Namens bedeutet, die Tabellen zu lesen, nicht der Zeichenkette zu vertrauen. Hol dir die kostenlose Version auf der Glass.NET-Downloadseite und öffne die IL-Ansicht beim nächsten Outer<...>.Inner<...>, das du lesen musst.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.