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

Den `with`-Ausdruck dekompilieren: wie Glass.NET Record-Clone-Stellen rekonstruiert

Ein `with`-Ausdruck hinterlässt kein Schlüsselwort im IL – er ist ein virtueller Aufruf einer versteckten `<Clone>$`-Methode, gefolgt von einer Reihe von init-only-Settern. Glass.NET liest genau diese Form wieder als `record with { … }` ein. Hier ist der vollständige Weg source → IL → rekonstruiertes C# für die nicht-destruktive Mutation.

Ein with-Ausdruck gehört zu den scheinbar magischsten Bestandteilen des modernen C#: Man nimmt ein unveränderliches Record, schreibt original with { Price = 9.99m } und erhält eine frische Kopie mit einem geänderten Feld und allem anderen unverändert. Nicht-destruktive Mutation. Doch es gibt keinen with-Opcode, keine Anweisung „klone dies, aber ändere jenes” in der CLR. Wenn der Compiler fertig ist, ist der gesamte Ausdruck zu einem schlichten virtuellen Methodenaufruf geworden, gefolgt von ein paar Feld-Speicherungen. Das Schlüsselwort with aus dieser Form zu rekonstruieren, ist ein kleiner, präziser Mustervergleich – und eine gute Gelegenheit zu sehen, wie Glass.NET, der kostenlose .NET-Dekompiler, Sprachfeatures rekonstruiert, die nur als Konventionen in den Metadaten existieren.

Dieser Artikel verfolgt eine with-Stelle bis hinunter zum IL und wieder hinauf zum C#. Wenn Sie die Mechanik der Record-Deklaration selbst wollen (EqualityContract, Wertgleichheit, PrintMembers), ist das ein eigener Fingerabdruck; hier interessiert uns nur die Aufrufstelle des Clonings.

Der Quellcode

Beginnen wir mit einem winzigen Record und einer einzigen nicht-destruktiven Aktualisierung:

public record Product(string Name, decimal Price, int Stock);

public static class Catalog
{
    public static Product Discount(Product p, decimal newPrice) =>
        p with { Price = newPrice, Stock = p.Stock - 1 };
}

Discount gibt ein neues Product zurück, das Name teilt, newPrice übernimmt und Stock dekrementiert – ohne jemals p zu mutieren. Zwei Dinge müssen im Hintergrund geschehen: Das Objekt muss kopiert werden, und dann müssen die beiden benannten Member auf der Kopie überschrieben werden. Genau das zeigt das IL.

Was der Compiler emittiert

Das Record selbst erhält zwei synthetisierte Member, die with ermöglichen: einen geschützten Kopierkonstruktor, der jedes Feld klont, und eine virtuelle Clone-Methode, die der C#-Compiler <Clone>$ nennt (die spitzen Klammern stellen sicher, dass man im Quellcode niemals damit kollidieren kann). Die Clone-Methode ruft lediglich den Kopierkonstruktor auf:

// Synthetisiert auf dem Record — hier mit lesbaren Namen gezeigt
protected Product(Product original)
{
    Name  = original.Name;
    Price = original.Price;
    Stock = original.Stock;
}

public virtual Product <Clone>$() => new Product(this);

Der with-Ausdruck in Discount kompiliert zu einem callvirt von <Clone>$ und dann zu einer Speicherung in jede innerhalb der geschweiften Klammern benannte Eigenschaft. Hier ist der Methodenrumpf, wie ildasm/Glass ihn zeigt:

.method public hidebysig static
    class Product Discount (class Product p, valuetype [System.Runtime]System.Decimal newPrice) cil managed
{
    .maxstack 3
    .locals init (class Product V_0)

    IL_0000: ldarg.0                       // p
    IL_0001: callvirt   instance class Product Product::'<Clone>$'()
    IL_0006: stloc.0                        // V_0 = clone of p
    IL_0007: ldloc.0
    IL_0008: ldarg.1                        // newPrice
    IL_0009: callvirt   instance void Product::set_Price(valuetype [System.Runtime]System.Decimal)
    IL_000e: ldloc.0
    IL_000f: ldarg.0                        // p
    IL_0010: callvirt   instance int32 Product::get_Stock()
    IL_0015: ldc.i4.1
    IL_0016: sub
    IL_0017: callvirt   instance void Product::set_Stock(int32)
    IL_001c: ldloc.0
    IL_001d: ret
}

Liest man es von oben nach unten, ist die Form unverkennbar: ein callvirt zu einer Methode namens <Clone>$, deren Ergebnis in einer temporären Variable geparkt wird, dann eine Folge von Setter-Aufrufen für Eigenschaften auf genau dieser temporären Variable und schließlich die Rückgabe der temporären Variable. Die Setter sind set_Price und set_Stock, die init-only-Setter des Records, hier aufrufbar, weil der Kopierkonstruktor und das Lowering des with in einem Initialisierungskontext ausgeführt werden.

Das Muster, auf das Glass achtet

Glass sucht nicht nach einem Flag, das sagt „dies war ein with”. Ein solches Flag gibt es nicht. Es erkennt die strukturelle Signatur des gelowerten Ausdrucks:

Recognizing a `with` expression in IL IL sequence callvirt <Clone>$() stloc V_0 ldloc V_0 ... set_Price ldloc V_0 ... set_Stock ldloc V_0 ; ret Match test callee is compiler method named <Clone>$ ? temp only mutated by init setters? Reconstructed C# p with { Price = newPrice, Stock = p.Stock - 1 } No `with` opcode exists — the keyword is inferred from the clone-then-set shape.

Die Erkennungsregel, präzise formuliert, lautet: ein Aufruf einer synthetisierten <Clone>$-Methode, deren Ergebnis in einer temporären Variable gespeichert wird, wobei diese temporäre Variable anschließend nur über init-only-Setter (oder direkte Feld-Speicherungen) mutiert wird, bevor sie als Wert verwendet wird. Trifft dies zu, kollabieren der Clone-Aufruf plus die Setter-Folge zu einem einzigen with-Ausdruck; der Empfänger von <Clone>$ wird zum Operanden vor with, und jeder Setter wird zu einem Member = value-Eintrag innerhalb der geschweiften Klammern.

Was Glass rekonstruiert

Lassen Sie es durch den Dekompiler laufen:

glass decompile Catalog.dll --type Catalog --member Discount

Glass erzeugt:

public static Product Discount(Product p, decimal newPrice)
{
    return p with
    {
        Price = newPrice,
        Stock = p.Stock - 1
    };
}

Das ist der ursprüngliche Quellcode, bis hin zur Reihenfolge der Initialisierer-Einträge (Glass bewahrt die Setter-Reihenfolge aus dem IL, die der Quellcode-Reihenfolge entspricht). Die temporäre Variable V_0, der <Clone>$-Aufruf und die beiden set_-Aufrufe sind allesamt im Schlüsselwort verschwunden – was die ehrliche Rekonstruktion ist, denn genau das hat der C#-Programmierer geschrieben.

Wenn das Muster nicht zutrifft

Der Wert eines strukturellen Vergleichs liegt darin, dass er ehrlich degradiert. Sieht Glass einen <Clone>$-Aufruf, dessen Ergebnis auf eine Weise mutiert wird, die ein with-Block nicht ausdrücken kann – etwa eine Schleife, die Elemente schreibt, ein Methodenaufruf, der kein init-Setter ist, oder eine Verzweigung zwischen Clone und Speicherungen –, dann erzwingt es kein with. Es fällt darauf zurück, den wörtlichen Clone-Aufruf und die einzelnen Zuweisungen anzuzeigen, denn ein with dort zu erfinden wäre eine Lüge über den Kontrollfluss. Sie können das selbst sehen, indem Sie --no-pattern with übergeben, um die rohe gelowerte Form mit der rekonstruierten zu vergleichen:

glass decompile Catalog.dll --member Discount --no-pattern with
public static Product Discount(Product p, decimal newPrice)
{
    Product product = p.<Clone>$();   // raw: the clone call is explicit
    product.Price = newPrice;
    product.Stock = p.Stock - 1;
    return product;
}

Beide Formen nebeneinander zu sehen ist nützlich, wenn Sie ein unbekanntes Assembly prüfen – vielleicht Ihren eigenen Release-Build ohne PDB oder eine Drittanbieter-Bibliothek, mit der Sie interoperieren müssen – und bestätigen wollen, dass eine Methode tatsächlich ein schlichtes Kopieren-und-Setzen tut und nicht etwas Subtileres, das sich hinter einem Clone verbirgt.

Record Structs: eine andere Form

Eine Feinheit, die zu kennen sich lohnt. Ein record struct hat keine <Clone>$-Methode, denn Werttypen werden durch Zuweisung kopiert – es gibt nichts aufzurufen. Für readonly record struct Point(int X, int Y) lowert der with-Ausdruck zu einer Kopie des Structs auf dem Stack (ein ldobj/stloc des gesamten Werts oder schlicht eine neue lokale Variable, die aus der Quelle initialisiert wird), gefolgt von derselben init-Setter-Folge. Glass erkennt diese Form ebenfalls: Eine Wertkopie eines Record Structs gefolgt von init-only-Settern ist die Struct-Variante von with, und es rekonstruiert dieselbe Syntax source with { … }. Das Signal unterscheidet sich – eine Struct-Kopie statt eines callvirt <Clone>$() –, aber die Rekonstruktionsregel ist dieselbe: kopieren, dann die benannten Member überschreiben, dann verwenden.

Warum das für das Lesen echten Codes zählt

with-Ausdrücke sind im modernen C# überall: Konfigurationsobjekte, die durch eine Pipeline gereicht werden, Zustandsaktualisierungen in einem Reducer, DTOs, die mit einem angepassten Feld kopiert werden. Dekompiliert man solchen Code ohne Erkennung, erhält man ein Dickicht aus <Clone>$()-Temporärvariablen und verstreuten Settern, das die einzige Absicht hinter jedem verdeckt: eine Kopie mit diesen Änderungen erstellen. Das wieder zu with zu kollabieren ist der Unterschied zwischen dem Lesen des Entwurfs einer Person und dem Lesen der Buchführung des Compilers.

Glass ist ein kostenloser, rein statischer Dekompiler, der genau für diese Art des Verstehens gebaut ist: Ihre eigenen Assemblies, Ihre Abhängigkeiten, Ihre Legacy-Builds. Er liest IL zu C#; er führt nichts aus, patcht nichts und verändert nichts. Richten Sie ihn auf eine DLL in der Visual-Studio-nativen Oberfläche, in der CLI oder über MCP, und das Schlüsselwort with kehrt überall dort zurück, wo die Form klonen-dann-setzen besagt, dass es stehen sollte.

Nebula.NET testen

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