Wie das field-Schlüsselwort von C# 14 dekompiliert
Das field-Schlüsselwort verwendet dasselbe <Name>k__BackingField wieder, das eine Auto-Property ausgibt, also sind die Metadaten identisch. Die Entscheidung, field darzustellen, liegt vollständig im IL des Accessors. So liest Glass.NET es zurück.
C# 14 hat das kontextbezogene Schlüsselwort field hinzugefügt: Innerhalb eines Property-Accessors können Sie jetzt field schreiben, um das vom Compiler synthetisierte Hintergrundfeld zu erreichen, ohne es selbst zu deklarieren. Es verwandelt das verbreitete Muster „Auto-Property, aber mit ein wenig Validierung” — zuvor eine Pflichtarbeit mit zwei Mitgliedern: ein privates Feld plus eine vollständige Property — in eine einzige Property, deren Accessoren ihre Arbeit erledigen und dann field lesen oder schreiben. Es ist ein kleines Feature mit überproportionaler Wirkung auf den Alltagscode, und es verbreitet sich bereits schnell.
Es ist auch ein wirklich interessantes Dekompilierungsproblem, denn field ist in den Metadaten unsichtbar. Das wiederverwendete Hintergrundfeld ist genau dasselbe <Name>k__BackingField, das eine gewöhnliche Auto-Property ausgibt, und trägt genau dieselbe [CompilerGenerated]-Markierung. Kein neues Attribut, kein Flag, nichts in der Property-Tabelle, das vermerkt „diese Property hat field verwendet”. Der gesamte Unterschied zwischen { get; set; } und einer Property mit field liegt an einer einzigen Stelle: in den Rümpfen der Accessor-Methoden. Ein Dekompilierer, der das Feld und die Property-Zeilen liest, lernt nichts; er muss das IL von get_ und set_ lesen und pro Accessor entscheiden, ob das, was er sieht, eine triviale Durchreiche oder echte Arbeit ist.
Dieser Beitrag zeigt die identischen Metadaten, die beide Konstruktionen teilen, die drei Accessor-Formen, die die Entscheidung in die eine oder andere Richtung erzwingen, und wie Glass.NET jede rekonstruiert.
Die zwei Konstruktionen, die eine Metadaten-Form teilen
Hier sind eine gewöhnliche Auto-Property und eine Property mit field, deren Accessoren zufällig trivial sind:
// Gewöhnliche Auto-Property
public string A { get; set; }
// field-Schlüsselwort, aber die Accessoren tun nichts Zusätzliches
public string B { get => field; set => field = value; }
Beide kompilieren zu denselben drei Metadaten-Teilen: einem privaten Hintergrundfeld, einem get_-Accessor und einem set_-Accessor. Das Feld für A:
.field private string '<A>k__BackingField'
.custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
= ( 01 00 00 00 )
Das Feld für B ist bis auf den Namen identisch, '<B>k__BackingField'. Dieselbe Sichtbarkeit, dasselbe [CompilerGenerated], alles gleich. Und die Accessor-Rümpfe sind ebenfalls identisch — der Getter beider ist ein bloßes Laden, der Setter ein bloßes Speichern:
.method public hidebysig specialname instance string get_A () cil managed
{
.custom instance void [...]CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
ldarg.0
ldfld string C::'<A>k__BackingField'
ret
}
.method public hidebysig specialname instance void set_A (string 'value') cil managed
{
.custom instance void [...]CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
ldarg.0
ldarg.1
stfld string C::'<A>k__BackingField'
ret
}
Das ist die entscheidende Tatsache: get => field; set => field = value; und { get; set; } sind dasselbe Programm. Der Compiler gibt Byte für Byte identisches IL aus. Für einen Dekompilierer gibt es nichts wiederherzustellen, weil es nichts zu unterscheiden gibt — und daher ist die richtige Antwort die einfachere. Glass stellt beide als { get; set; } dar. Bs Quelltext wörtlich zu reproduzieren wäre Rauschen; die beiden Formen sind austauschbar, und die Auto-Property ist das, was jeder Leser erwartet.
Der Dekompilierer erkennt die Durchreiche an ihrer Form. Der Getter muss genau ldarg.0; ldfld <backing>; ret sein, der Setter genau ldarg.0; ldarg.1; stfld <backing>; ret, und das Feld muss das vom Compiler erzeugte <Name>k__BackingField sein, das von nichts außer diesen beiden Accessoren referenziert wird. Passt all das, haben Sie eine echte Auto-Property, welche Syntax sie auch erzeugt hat.
Ein Setter, der Arbeit leistet: das field-Schlüsselwort wird erzwungen
Brechen wir nun die Durchreiche auf der Set-Seite — der häufigste Grund, zu field zu greifen:
public string Name
{
get => field;
set => field = value ?? string.Empty;
}
Der Getter ist weiterhin eine Durchreiche, aber der Setter führt jetzt den Null-Coalescing-Operator aus, bevor er speichert. Dieses ?? string.Empty wird zur Standard-Sequenz dup / brtrue / pop abgesenkt:
.method public hidebysig specialname instance void set_Name (string 'value') cil managed
{
ldarg.0
ldarg.1
dup
brtrue.s IL_000a
pop
ldsfld string [System.Runtime]System.String::Empty
IL_000a:
stfld string Person::'<Name>k__BackingField'
ret
}
Lesen Sie den Stack: ldarg.0 legt this für das abschließende stfld ab; ldarg.1 lädt value; dup kopiert es; brtrue.s behält die Kopie, wenn sie nicht null ist, und springt zum Speichern; andernfalls verwirft pop den Null-Wert, und ldsfld String::Empty setzt die leere Zeichenfolge ein. So oder so wird der Wert auf dem Stack in das Hintergrundfeld gespeichert. Das ist eindeutig nicht die Zwei-Befehls-Durchreiche, also ist die Zusammenfassung zur Auto-Property vom Tisch.
Damit bleibt dem Dekompilierer ein Problem, das nur C# 14 sauber lösen kann. Das Hintergrundfeld heißt <Name>k__BackingField, und diese spitzen Klammern machen es zu einem unaussprechlichen Namen — einem Namen, den der Compiler reserviert, damit kein Quelltext-Bezeichner mit ihm kollidieren kann. Sie können ihn nicht tippen. Bevor es das field-Schlüsselwort gab, musste ein Dekompilierer hier ein privates Feld mit einem legalen Namen erfinden und beide Accessoren umschreiben, um es zu verwenden, womit aus einer einzeiligen Property ein Feld plus eine vollständige Property wurde und sich die Form des Typs änderte. Jetzt ist die Rekonstruktion exakt:
public string Name
{
get => field;
set => field = value ?? string.Empty;
}
Glass stellt den trivialen Getter als get => field; dar (er könnte ebenso weggelassen werden, aber ihn explizit zu lassen spiegelt den echten Accessor wider) und den echten Setter mit field anstelle des synthetisierten Speichers. Die Ausgabe kompiliert zurück zum identischen IL.
Ein Getter, der Arbeit leistet: der asymmetrische Fall
Die Entscheidung erfolgt pro Accessor, nicht pro Property, also ist das Spiegelbild genauso gültig — ein trivialer Setter und ein Getter, der rechnet:
public string Display
{
get => field ?? "(unset)";
set => field = value;
}
Hier ist der Setter eine bloße Durchreiche, aber der Getter führt ?? "(unset)" aus:
.method public hidebysig specialname instance string get_Display () cil managed
{
ldarg.0
ldfld string Person::'<Display>k__BackingField'
dup
brtrue.s IL_000b
pop
ldstr "(unset)"
IL_000b:
ret
}
Dasselbe Muster dup / brtrue / pop, diesmal mit dem Einsetzen eines Literals, wenn der gespeicherte Wert null ist. Weil ein Accessor Arbeit leistet, kann die Property nicht zu { get; set; } zusammengefasst werden: Sie so darzustellen würde den Standardwert stillschweigend verwerfen. Glass legt den Getter mit field offen und lässt den Setter trivial:
public string Display
{
get => field ?? "(unset)";
set => field = value;
}
Dieselbe Überlegung erstreckt sich auf die verzögerte Initialisierung — public Cache C => field ??= new(); — wo das zusammengesetzte ??= des Getters durch field liest, prüft, konstruiert und speichert und die Property überhaupt keinen Setter hat. Die Form des IL unterscheidet sich, aber die Regel, die Glass anwendet, ist in jedem Fall dieselbe Konstante: das vom Compiler erzeugte Hintergrundfeld finden, jeden Accessor gegen die Durchreiche-Vorlage prüfen und field für jeden Accessor darstellen, der den Test nicht besteht.
Eine Property mit Glass zurücklesen
Da die gesamte Entscheidung auf dem Accessor-IL beruht, ist die IL-Ansicht der schnellste Weg, zu bestätigen, was eine Property wirklich tut. Richten Sie Glass auf die Assembly und geben Sie die Property aus:
$ glass export ./People.dll --member "P:Person.Name" --il
Das druckt das Hintergrundfeld, beide Accessor-Rümpfe und die MethodSemantics-Verknüpfungen, sodass Sie selbst sehen, ob ein Accessor eine Durchreiche ist oder Arbeit leistet, bevor er <Name>k__BackingField berührt. Lassen Sie --il weg, und Glass rekonstruiert das C#:
$ glass export ./People.dll --member "P:Person.Name"
public string Name
{
get => field;
set => field = value ?? string.Empty;
}
Sie erhalten dasselbe Ergebnis in der Nebeneinander-Ansicht der App: Wählen Sie die Property aus, und das IL-Fenster zeigt die Accessor-Rümpfe neben dem rekonstruierten Quelltext, sodass der Durchreiche-Test, den der Dekompilierer gerade durchgeführt hat, direkt mit dem Auge überprüfbar ist. Glass verwendet dieselbe ICSharpCode.Decompiler-Engine in der CLI und in der UI, und alles ist statisch: Es liest die Metadaten und das IL und rekonstruiert den Quelltext. Es führt die Accessoren nie aus, und genau deshalb ist es sicher, es auf eine Abhängigkeit zu richten, bei der Sie noch entscheiden, ob Sie ihr vertrauen.
Das field-Schlüsselwort wird überall sein, weil es den einen Reibungspunkt beseitigt, der Leute dazu brachte, Properties mit vollständigem Hintergrundfeld zu schreiben. Zu wissen, dass es keinen Fingerabdruck in den Metadaten hinterlässt — dass ein Dekompilierer es rein aus der Form des Accessor-Rumpfs wiederherstellt — lohnt sich beim nächsten Mal, wenn Sie lesen, wie eine Bibliothek eine Property validiert, an die Sie Daten übergeben, oder wenn Sie debuggen, warum Ihr eigener Setter einen unerwarteten Wert normalisiert hat. Holen Sie sich die neueste Version von der Glass.NET-Download-Seite und lesen Sie das nächste field, dem Sie begegnen.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.