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

Wie Glass einen C#-14-Erweiterungsblock rekonstruiert

Ein C#-14-Erweiterungsblock wird zu einem verborgenen verschachtelten Skelett-Typ plus gewöhnlichen statischen Methoden auf der enthaltenden Klasse abgesenkt. Dieser Beitrag geht die Metadaten durch, die Glass.NET liest, um die beiden Hälften zu paaren und den Erweiterungsblock zu rekonstruieren, einschließlich seiner Erweiterungseigenschaften und statischen Mitglieder, die die klassische Form mit this-Parameter nie ausdrücken konnte.

C# 14 erlaubte endlich, list.IsEmpty und Point.Origin zu schreiben, wobei IsEmpty und Origin deine Ergänzungen zu Typen sind, die dir nicht gehören. Der klassische this-Parameter-Trick konnte das nie: Er fügte nur Methoden hinzu, weil ein Eigenschaften-Getter keinen ersten Parameter zum Markieren hat. Der neue Erweiterungsblock schließt die Lücke. Und weil die Lücke in der Sprache lag, nicht in der Runtime, musste der Compiler eine Metadatenform erfinden, um sie zu transportieren. Diese Form zurück in einen lesbaren Block zu dekompilieren ist ein Zwei-Hälften-Puzzle, und dieser Beitrag geht es für Glass.NET durch.

Der Quellcode

Ein einziger Erweiterungsblock, der IEnumerable<T> eine Instanzeigenschaft, eine Instanzmethode und eine statische Eigenschaft hinzufügt:

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();

        public IEnumerable<T> WhereNotNull()
            => source.Where(x => x is not null);

        public static IEnumerable<T> Empty => [];
    }
}

Drei Mitglieder, ein Empfänger namens source. Nichts hiervon entspricht einer klassischen Erweiterungsmethode außer, lose, WhereNotNull. IsEmpty ist eine Eigenschaft; Empty ist ein statisches Mitglied, auf das als EnumerableExtensions.Empty ganz ohne Empfänger zugegriffen wird. Keine this-Parameter-Syntax drückt irgendetwas davon aus.

Was der Compiler emittiert

Der Empfänger und die Mitgliedssignaturen überleben nicht als C#. Sie überleben als ein verschachtelter Typ, den der Compiler innerhalb von EnumerableExtensions synthetisiert, einen pro Erweiterungsblock, mit einem unaussprechlichen Namen wie <>E__0. Dieser verschachtelte Typ ist das Skelett. Sein wichtigstes Mitglied ist eine Markermethode namens <Extension>$, deren einziger Parameter der Empfänger ist:

.class nested public abstract sealed auto ansi beforefieldinit '<>E__0'<T>
{
    .method public hidebysig specialname static
        void '<Extension>$'(class [System.Runtime]System.Collections.Generic.IEnumerable`1<!T> source) { }

    .property instance bool IsEmpty() { .get instance bool get_IsEmpty() }
    .method public hidebysig specialname instance bool get_IsEmpty() { ldnull throw }
    .method public hidebysig instance class IEnumerable`1<!T> WhereNotNull() { ldnull throw }
    .property class IEnumerable`1<!T> Empty() { .get static class IEnumerable`1<!T> get_Empty() }
    .method public hidebysig specialname static class IEnumerable`1<!T> get_Empty() { ldnull throw }
}

Zwei Dinge sind zu beachten. Der Name des Empfängers — source — bleibt erhalten, als Parametername von <Extension>$. Und alle Skelettkörper sind ldnull; throw. Diese Methoden werden nie ausgeführt; sie existieren nur, damit die öffentliche Form jedes Mitglieds (Name, Signatur, Attribute, statisch-oder-Instanz) in den Metadaten unabhängig vom Code lebt, der es implementiert.

Der Code, der tatsächlich läuft, sitzt auf der enthaltenden statischen Klasse, unter inhaltsbasierten verstümmelten Namen, mit dem als echtem ersten Parameter eingefügten Empfänger für die Instanzmitglieder:

.class public abstract sealed auto ansi beforefieldinit EnumerableExtensions
{
    .method public hidebysig static bool
        get_IsEmpty<T>(class IEnumerable`1<!T> source)
    {
        ldarg.0  call bool [System.Linq]System.Linq.Enumerable::Any<!!T>(...)
        ldc.i4.0  ceq  ret
    }
    .method public hidebysig static class IEnumerable`1<!T>
        WhereNotNull<T>(class IEnumerable`1<!T> source) { /* real body */ }
    .method public hidebysig static class IEnumerable`1<!T>
        get_Empty<T>() { /* real body, no receiver */ }
}

Die Instanzmitglieder (get_IsEmpty, WhereNotNull) nehmen source als ersten Parameter. Das statische Mitglied (get_Empty) nicht: Ein statisches Erweiterungsmitglied hat keinen Empfänger, also ist seine Implementierung eine gewöhnliche generische statische Methode. Diese Asymmetrie ist das nützlichste Signal im ganzen Schema: So entscheidet ein Decompiler, ob ein Mitglied als static oder als Instanzmitglied in den Block kommt.

Die Paarung

Die Rekonstruktion ist ein Join. Für jedes Skelettmitglied in <>E__0 findet Glass die passende Implementierung auf der enthaltenden Klasse und liest den Körper von dort; es liest die Form — Name, Rückgabetyp, statisch-oder-Instanz, Attribute — aus dem Skelett; und es liest den Empfänger einmal, aus <Extension>$, um source in den Gültigkeitsbereich jedes Instanzkörpers zu stellen.

verschachtelter Typ <>E__0<Extension>$(source)Empfänger: Name + TypSkelett: IsEmpty getSkelett: WhereNotNullSkelett: Empty (static)Form + AttributeKörper werfenenthaltende statische Klasseget_IsEmpty(source)WhereNotNull(source)get_Empty() kein recvechte IL-Körperextension<T>(IEnumerable<T>source)bool IsEmptyWhereNotNull()static EmptyForm + Körper vereint
Das Skelett trägt die Form jedes Mitglieds und den Empfänger; die enthaltende Klasse trägt die Körper. Glass paart sie nach Signatur und gibt den Block aus.

Die Entscheidung statisch-gegen-Instanz folgt direkt aus der Parameterliste der Implementierung. get_IsEmpty<T>(IEnumerable<T> source) hat den Empfänger als ersten Parameter, also ist IsEmpty ein Instanzmitglied und sein Körper wird mit source im Gültigkeitsbereich ausgegeben. get_Empty<T>() hat keinen Empfänger, also ist Empty static und in seinem Gültigkeitsbereich ist nur der Typparameter. Glass muss sich nicht allein auf das static-Flag des Skeletts verlassen: Die Form der Implementierung bestätigt es.

Das Ergebnis ist der Block, wortgetreu wieder zusammengesetzt:

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();
        public IEnumerable<T> WhereNotNull() => source.Where(x => x is not null);
        public static IEnumerable<T> Empty => [];
    }
}

Wie du das nutzt

Richte Glass auf jede Assembly, die .NET 10 oder neuer anvisiert und Erweiterungsblöcke verwendet — deine eigenen Bibliotheken, eine lizenzierte Abhängigkeit, deren Quellcode du verloren hast, ein Paket, gegen das du ein Interop-Problem debuggst. Im Baum zeigt die enthaltende Klasse ihre Mitglieder; klappe den synthetisierten Typ <>E__0 auf, und Glass rendert den wiederhergestellten extension-Block statt eines bloßen verschachtelten Typs voller werfender Stubs. Die CLI- und MCP-Oberflächen liefern dir dieselbe Rekonstruktion für skriptgesteuerte Prüfung:

glass decompile EnumerableExtensions.dll --type EnumerableExtensions

Wenn du nur den Empfänger und die Mitgliederliste ohne die Körper bestätigen willst, zeigt die IL-Ansicht die Markermethode <Extension>$ und die Skelette direkt — die Grundwahrheit, auf der die C#-Ansicht aufgebaut ist.

Wann es bricht

Die Paarung erfolgt nach Signatur, und Signaturkollisionen sind die Stelle, an der es ausfranst. Wenn zwei Erweiterungsblöcke in derselben Klasse Mitglieder deklarieren, deren abgesenkte Implementierungen zu Formen verstümmeln, die ein Werkzeug nicht unterscheiden kann, kann ein Decompiler einen Körper an das falsche Skelett hängen; Glass stützt den Join auf die vollständige generische Signatur und den Empfängertyp, um dies zu vermeiden, aber adversarisch verstümmelte Assemblies können jeden Leser trotzdem verwirren. Eine zweite Grenze ist das Mischen: Eine Klasse kann sowohl klassische Erweiterungsmethoden mit this-Parameter als auch neue Erweiterungsblöcke enthalten, und beide verwenden unterschiedliche Metadaten — das [Extension]-Attribut für die alten, das <>E__N-Skelett für die neuen — sodass eine getreue Dekompilierung jede in ihrer eigenen Form zeigt, statt die eine in die andere zu zwingen. Schließlich sind die unaussprechlichen Namen (<>E__0, <Extension>$) compilerintern und haben sich über Vorschauversionen hinweg geändert; Glass erkennt die Form, nicht einen hartcodierten Namen, aber eine künftige Absenkung könnte die Kodierung verschieben und eine Leser-Aktualisierung erfordern.

Fazit

Ein Erweiterungsblock ist eine Gruppierung zur Kompilierzeit ohne Existenz zur Laufzeit, zur Buildzeit aufgespalten in ein Skelett, das sich die Form merkt, und eine Implementierung, die den Code trägt. Ihn wieder aufzubauen ist ein Join: Lies den Empfänger einmal aus <Extension>$, paare jedes Skelettmitglied mit seiner Implementierung und lass den ersten Parameter der Implementierung Instanz von statisch unterscheiden. Mache diesen Join richtig, und eine Erweiterungseigenschaft — etwas, das die alte Syntax nie schreiben konnte — kommt genau so zurück, wie sie geschrieben wurde.

Nebula.NET testen

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