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

Wie Glass generische Methoden-Instanziierungen liest

Ein generischer Methodenaufruf wird zu einem MethodSpec-Token mit einem separaten Typargument-Blob kompiliert. So liest Glass.NET diesen Blob, ersetzt die !!0-Platzhalter und entscheidet, wann das wiederhergestellte C# überhaupt explizite Typargumente braucht.

Rufen Sie eine generische Methode zweimal mit verschiedenen Typen auf, und der Compiler kopiert die Methode nicht. Er gibt den Rumpf nur einmal aus, gegen Platzhalter, und hält die Typargumente jedes Aufrufs in einer winzigen separaten Struktur fest. Ein Dekompiler, der diese Trennung nicht versteht, verliert entweder die Typargumente oder druckt sie dort, wo C# sie nie geschrieben hätte. Hier ist der Mechanismus, mit dem Glass.NET es exakt richtig macht.

Die eigentliche Frage

Betrachten Sie eine Methode, die über einen Typ generisch ist, und die beiden Aufrufe, die sie instanziieren:

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}");
    }
}

Es gibt ein einziges Max in der kompilierten Assembly. Sein Rumpf ist gegen einen Typparameter geschrieben, nicht gegen int oder string. Wohin sind also das int und das string verschwunden, und wie setzt Glass sie wieder ein, ohne spitze Klammern zu erfinden, die der Quelltext nie hatte?

Der Rumpf wird einmal geschrieben, gegen Platzhalter

Dekompilieren Sie die Methodendefinition, und der generische Parameter erscheint überall dort als !!T, wo im Quelltext ein T stand:

.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
}

Hier sind zwei Indexräume im Spiel, und sie auseinanderzuhalten ist der ganze Kern. !!T (zwei Zeichen) ist der generische Parameter der Methode. Das !0 (ein Zeichen) in IComparable 1<!!T>::CompareTo(!0)ist der generische Parameter des **Typs** – der einzige Parameter vonIComparable<>` selbst. Die CLI hält Methoden- und Typparameter in getrennten Nummerierungsräumen, genau damit eine generische Methode auf einem generischen Typ nie den Index 0 gegen den Index 0 abgrenzen muss.

Beachten Sie auch das Präfix constrained. !!T: Da T ein Werttyp sein kann, weiß der Compiler zur Übersetzungszeit nicht, ob CompareTo ein callvirt mit Boxing braucht. Das Präfix überlässt diese Entscheidung dem JIT, der die Methode des Structs direkt ohne Allokation aufruft. Das ist eine unmittelbare Folge von where T : IComparable<T>, und Glass stellt die Einschränkung in der Methodensignatur wieder her, statt sie wegzulassen.

Die Typargumente liegen in einem MethodSpec

Der Rumpf erwähnt int nie. Also muss die Aufrufstelle die Instanziierung tragen. Dekompilieren Sie Main, und jeder Aufruf ist eine einzelne Instruktion gegen ein MethodSpec-Token:

ldc.i4.3
ldc.i4.7
call   !!0 Program::Max<int32>(!!0, !!0)
...
ldstr  "a"
ldstr  "b"
call   !!0 Program::Max<string>(!!0, !!0)

Beide Instruktionen zeigen auf dieselbe generische Methodendefinition, aber über zwei verschiedene MethodSpec-Zeilen (Metadaten-Tabelle 0x2B). Jede Zeile hat zwei Spalten: Method, eine Referenz auf das generische Max, und Instantiation, einen Blob-Index. Der Blob ist eine GENERICINST-Signatur: ein Ein-Byte-Marker für die Aufrufkonvention 0x0A, eine Argumentanzahl und dann ein kodierter Typ pro Argument.

Aufrufstelle (IL)call !!0Program::Max<int32>(token 0x2B000001)→MethodSpec-Zeile 0x2BMethod → MethodDef Max<T>(der Rumpf, einmal gegen !!0 geschrieben)Instantiation → blob #37GENERICINST-Blob0A 01 08GENERICINST, 1 Arg, I40x08 = ELEMENT_TYPE_I4→Ersetzen + ableiten!!0 → intArgs sind int → Inferenz findet <int>daher entfallen die KlammernWiederhergestelltes C#int m = Max(3, 7);
Ein Methodenrumpf, zwei MethodSpec-Zeilen. Der Instanziierungs-Blob – nicht der Rumpf – trägt den konkreten Typ, und die Inferenz entscheidet, ob die Klammern zurückkehren.

Für Max<int32> lauten die Blob-Bytes 0A 01 08: Aufrufkonvention GENERICINST (0x0A), ein Argument (0x01) und ELEMENT_TYPE_I4 (0x08). Für Max<string> ist das letzte Byte 0x0E (ELEMENT_TYPE_STRING). Drei Bytes sind der gesamte Unterschied zwischen den beiden Aufrufen. Alles andere – der Rumpf, die Parameterliste, der Rückgabewert – wird geteilt.

Erst ersetzen, dann über die Klammern entscheiden

Glass geht dies in zwei Schritten durch. Zuerst löst es den MethodSpec auf: Method bis zum offenen generischen Max<T> folgen, Instantiation lesen, um die geordneten Typargumente [Int32] zu erhalten, und !!0 an Int32 binden. Das allein reicht schon, um ein korrektes, wenn auch ausführliches Max<int>(3, 7) zu drucken.

Der zweite Schritt ist das, was die Ausgabe wie Quelltext lesen lässt. C# erlaubt es, die Typargumente wegzulassen, wenn der Compiler sie aus den gewöhnlichen Argumenten ableiten kann. Hier sind beide Parameter vom Typ T und beide Argumente int, sodass die Inferenz T = int von selbst findet – weshalb der Quelltext Max(3, 7) schrieb und nicht Max<int>(3, 7). Glass bildet das nach: Nach der Ersetzung fragt es, ob ein erneutes Ausführen der Inferenz über den nicht annotierten Aufruf dieselbe geschlossene Methode treffen würde. Wenn ja, entfallen die Klammern.

Wenn die Inferenz die Argumente nicht wiederherstellen kann, behält Glass sie. Der klassische Fall ist ein Typargument, das nur an der Rückgabeposition auftaucht:

static T Create<T>() where T : new() => new T();

var list = Create<List<int>>();   // kein Argument zum Ableiten

Create hat keine Parameter, also schränkt nichts an der Aufrufstelle T ein. Das IL trägt Create<class List1>in seinem MethodSpec, und Glass mussCreate<List>()` wörtlich ausgeben: Das Entfernen der Klammern würde Code erzeugen, der nicht kompiliert.

Wenn die Heuristik vorsichtig bleiben muss

Die Inferenz-Wiederherstellung ist eine Ermessensfrage, und Glass neigt zur Korrektheit vor Kürze. Ist eine Methode so überladen, dass das Entfernen der Typargumente eine andere Überladung gewinnen ließe – oder den Aufruf mehrdeutig machte –, behält Glass die expliziten Argumente, auch wenn sich der Originalquelltext auf die Inferenz gestützt haben mag. Der dekompilierte Code ist dann etwas ausführlicher als der Quelltext, kompiliert aber nachweislich zum selben MethodSpec. Dieser Kompromiss ist beabsichtigt: Ein Dekompiler, der kürzeren Code erzeugt, der an die falsche Methode bindet, ist schlimmer als nutzlos.

Die andere ehrliche Grenze: Die Namen der Typargumente sind weg. Ein Blob kodiert System.Int32, niemals die Tatsache, dass das abgeleitete T des Autors an anderer Stelle TKey hieß. Namen generischer Parameter an Definitionen überleben in den Metadaten; die an sie an einer Aufrufstelle gebundenen Typen sind strukturell, also druckt Glass den echten Typ, int, was die Runtime ohnehin sieht.

Fazit

Ein generischer Aufruf in .NET ist eine Verknüpfung: ein geteilter Rumpf gegen Platzhalter plus ein MethodSpec pro Aufrufstelle, dessen Blob die echten Typen trägt. Lesen Sie den Blob, binden Sie !!0 bis !!n, halten Sie Methoden- und Typparameter in ihren getrennten Indexräumen, und lassen Sie dann die Inferenz über die Klammern entscheiden – und der dekompilierte Aufruf liest sich genau wie das C#, das ihn erzeugt hat. Glass.NET tut dies an jeder generischen Aufrufstelle, weshalb die Ausgabe lesbar ist statt einer Wand aus spitzen Klammern. Sehen Sie sich die IL- und Metadaten-Ansicht an, um die MethodSpec-Zeilen selbst zu inspizieren.

Nebula.NET testen

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