Wie ein Decompiler einen eigenen Collection-Builder erkennt
Ein Collection-Ausdruck, der auf deinen eigenen Typ mit [CollectionBuilder] zielt, reduziert sich auf einen Span und einen Factory-Aufruf, ohne dass eine Klammer im IL zurückbleibt. Hier sind die genauen Metadaten und die Heuristik, mit der Glass.NET ihn zurückfaltet, und der eine Fall, den es nicht entscheiden kann.
Collection-Ausdrücke wurden als syntaktischer Zucker verkauft, doch das Interessante ist, dass dieser Zucker erweiterbar ist. Setze [CollectionBuilder] auf einen Typ, und [1, 2, 3] erzeugt eine Instanz davon. Der Haken für jeden, der kompilierten Code liest: Nichts im emittierten IL enthält eine Klammer, eine Liste oder auch nur einen Hinweis darauf, dass der Autor einen Collection-Ausdruck geschrieben hat. Was du bekommst, ist ein ReadOnlySpan<T>, der aus dem Nichts erscheint und einer statischen Factory-Methode übergeben wird. Das ursprüngliche [...] daraus wiederherzustellen ist ein kleines, in sich geschlossenes Decompiler-Problem — und ein gutes Beispiel dafür, wie ein Decompiler aus einem Attribut statt aus einem Opcode schließt.
Die eigentliche Frage
Es gibt keine „Collection-Ausdruck“-Instruktion. Für einen Typ mit [CollectionBuilder] besteht der gesamte Beitrag des Compilers darin: einen Span der Elemente zu materialisieren und dann den bezeichneten Builder per call aufzurufen. Die Frage, die Glass beantworten muss, lautet also nicht was bedeutete dieser Opcode, sondern rekonstituiert dieser bestimmte Aufruf, mit dieser bestimmten Span-Quelle, einen Collection-Ausdruck — und wenn ja, für welchen Zieltyp. Dieses Schließen läuft rückwärts durch die Metadaten, nicht vorwärts durch die Instruktionen.
Eine eigene Collection, von Anfang bis Ende
Hier ist ein minimaler Collection-Typ, der sich anmeldet. Das Attribut benennt den Builder-Typ und die Methode; die Methode muss statisch sein und einen ReadOnlySpan<T> nehmen.
using System.Runtime.CompilerServices;
[CollectionBuilder(typeof(RingBuffer), nameof(RingBuffer.Create))]
public sealed class RingBuffer<T>
{
private readonly T[] _items;
internal RingBuffer(ReadOnlySpan<T> items) => _items = items.ToArray();
public int Count => _items.Length;
public ReadOnlySpan<T>.Enumerator GetEnumerator() => _items.AsSpan().GetEnumerator();
}
public static class RingBuffer
{
public static RingBuffer<T> Create<T>(ReadOnlySpan<T> items) => new(items);
}
Nun eine Stelle, die ihn mit konstanten Elementen verwendet:
public static RingBuffer<int> Build() => [10, 20, 30];
Der Compiler alloziert kein int[] und ruft keinen RingBuffer-Konstruktor auf. Für eine vollständig konstante primitive Nutzlast parkt er die drei Ganzzahlen in einem schreibgeschützten Datenfeld und baut den Span mit RuntimeHelpers.CreateSpan, das einen Span zurückgibt, der direkt auf dieses Feld zeigt — ganz ohne Heap-Allokation:
.method public static class RingBuffer`1<int32> Build() cil managed
{
ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12_Align=4'
'<PrivateImplementationDetails>'::'3C8CE...A1'
call valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>
[System.Runtime]System.Runtime.CompilerServices.RuntimeHelpers::CreateSpan<int32>(
valuetype [System.Runtime]System.RuntimeFieldHandle)
call class RingBuffer`1<!!0> RingBuffer::Create<int32>(
valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>)
ret
}
Drei Instruktionen. Die Klammern sind weg, die Elementanzahl überlebt nur als TypeSize=12 eines synthetischen Structs (12 Bytes / sizeof(int) = 3), und das einzige Wort, das all dies an den Quelltext bindet, ist das Create im abschließenden call.
Wenn die Elemente keine Konstanten sind
Tausche die Literale gegen Parameter, und der Span kann nicht mehr aus einem Datenfeld stammen: Es gibt nichts Konstantes zum Parken. Der Compiler synthetisiert einen [InlineArray(3)]-Puffertyp, alloziert ihn auf dem Stack, füllt ihn über eine generierte Hilfsmethode InlineArrayElementRef und nimmt mit InlineArrayAsReadOnlySpan einen Span darüber:
.locals init (valuetype '<>y__InlineArray3`1'<int32> V_0)
ldloca.s V_0
initobj valuetype '<>y__InlineArray3`1'<int32>
ldloca.s V_0
ldc.i4.0
call !!1& '<PrivateImplementationDetails>'::InlineArrayElementRef<valuetype '<>y__InlineArray3`1'<int32>, int32>(!!0&, int32)
ldarg.0
stind.i4
// … Index 1 aus ldarg.1, Index 2 aus ldarg.2 …
ldloca.s V_0
ldc.i4.3
call valuetype [System.Runtime]System.ReadOnlySpan`1<!!1> '<PrivateImplementationDetails>'::InlineArrayAsReadOnlySpan<valuetype '<>y__InlineArray3`1'<int32>, int32>(!!0&, int32)
call class RingBuffer`1<!!0> RingBuffer::Create<int32>(valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>)
Zwei unterschiedliche Span-Quellen, dasselbe Ziel: ein call an RingBuffer::Create über einem ReadOnlySpan<int>. Dieses Ziel ist die Invariante, an der Glass sich festmacht.
Die Wiederherstellungs-Heuristik
Glass behandelt das Zurückfalten als eine Bestätigung in vier Punkten. Es schreibt einen Aufruf nur dann in Klammer-Syntax um, wenn alle Punkte zutreffen.
- Der Aufruf gilt einer statischen Methode, die einen konstruierten Typ zurückgibt.
RingBuffer::Create<int32>gibtRingBuffer<int>zurück. Merke dir den RückgabetypCund die MethodeM. - Die Definition von
Cträgt[CollectionBuilder]und benennt diese Methode. Glass liest den Blob des benutzerdefinierten Attributs aufRingBuffer<T>: einSystem.Type-Argument (typeof(RingBuffer)) und einstring("Create"). Die aufgerufene Methode muss diese Methode auf diesem Typ sein. Eine Factory mit der richtigen Form, aber ohne das darauf zeigende Attribut ist kein Builder. - Das einzige Argument ist ein
ReadOnlySpan<E>, dessen ElementtypEzur Instanziierung des Builders passt. - Der Span wurde durch eine erkannte Form erzeugt — entweder
RuntimeHelpers.CreateSpan<E>über einem<PrivateImplementationDetails>-Feld oderInlineArrayAsReadOnlySpanüber einem frisch mitinitobjinitialisierten<>y__InlineArrayN-Local. Glass verfolgt den Span zu seinen Elementen zurück: der alsEdekodierte RVA-Blob oder die in jeden Slot des Inline-Arrays geschriebenen Werte.
Erst dann emittiert es [e0, e1, …], getypt auf C. Das Attribut aus Schritt 2 ist das ganze Spiel — es ist die einzige Metadaten-Angabe, die „eine Factory, die zufällig jemand mit einem Span aufrief“ von „dem Builder, den die Sprache an Klammern verdrahtet hat“ unterscheidet.
Der Fall, den es nicht entscheiden kann
Hier ist die ehrliche Grenze, und sie ist echt und kein Fehler. Betrachte zwei Quellen:
RingBuffer<int> a = [1, 2, 3];
RingBuffer<int> b = RingBuffer.Create([1, 2, 3]);
Die erste ist ein Collection-Ausdruck, der auf RingBuffer<int> zielt. Die zweite ist ein expliziter Aufruf von Create, dessen Argument [1, 2, 3] ein Collection-Ausdruck ist, der auf den Parameter ReadOnlySpan<int> zielt. Beide kompilieren zu byteidentischem IL: dasselbe CreateSpan und dasselbe call RingBuffer::Create. Keine Metadaten trennen sie, denn auf IL-Ebene gibt es nichts zu trennen — die Sprache definiert die erste als Kurzform der zweiten.
Glass löst das Unentschieden mit einer Regel, nicht mit einer Vermutung: Wenn das Ergebnis des Builder-Aufrufs selbst der direkte Wert einer Stelle ist, die auf den Collection-Typ getypt ist — ein Local-Initialisierer, ein return, ein Argument, das RingBuffer<int> erwartet — bevorzugt es die Klammer-Form und gibt [1, 2, 3] aus. Wenn das Ergebnis irgendwohin fließt, das nicht auf die Collection getypt ist (es wird sofort indiziert, dort übergeben, wo per impliziter Konvertierung ein ReadOnlySpan erwartet wird, oder der Builder ist eine Methode, die du offenkundig sehen wolltest), belässt es RingBuffer.Create([1, 2, 3]) unangetastet. Beide Darstellungen kompilieren zum ursprünglichen Assembly zurück; die Wahl betrifft, welche ein Mensch lieber liest, und das Entscheidungskriterium ist dokumentiert, damit die Ausgabe nie stillschweigend irreführt.
Eine zweite erwähnenswerte Grenze: Ist die Builder-Methode nicht generisch, lebt sie auf einem Typ ohne Bezug zur Collection, oder stammt der Span aus einer Quelle, die Glass nicht erkennt (etwa ein ReadOnlySpan<T>, den deine eigene Hilfsmethode zurückgibt), scheitert die Vier-Punkte-Prüfung gefahrlos, und du erhältst den wörtlichen call. Das ist die richtige Antwort: Alles andere wäre Erfindung.
Das beim Codelesen nutzen
Wenn du ein Assembly in Glass öffnest und ein nacktes [...] auf einem Typ siehst, den du nicht als eingebaute Collection erkennst, ist das dein Signal: Der Typ trägt [CollectionBuilder], und eine statische Factory nur einen Sprung entfernt definiert, wie er gebaut wird. Springe zum Attribut (die IL-Ansicht zeigt den Blob; die dekompilierte Ansicht zeigt das rekonstruierte [CollectionBuilder(typeof(...), "...")] auf dem Typ), und du hast den wahren Konstruktor gefunden, den die Klammern verbargen. Umgekehrt: Siehst du ein explizites Xyz.Create([...]), sagt dir Glass, dass es nicht beweisen konnte, dass der äußere Aufruf Zucker war — lies es als bewussten Factory-Aufruf.
Fazit
Ein Collection-Ausdruck mit [CollectionBuilder] hinterlässt keine syntaktische Spur im IL: nur einen Span und einen statischen Aufruf. Glass faltet ihn zurück, indem es aus dem Attribut auf dem Zieltyp und der Form des Spans schließt, nicht aus einer Instruktion — und wo zwei legale Quellen zu denselben Bytes kollabieren, wendet es ein deklariertes, zurückkompilierbares Entscheidungskriterium an, statt vorzugeben zu wissen, welche du getippt hast. Die wiederhergestellten Klammern zu lesen und zu wissen, wann sie eine Entscheidung statt einer Tatsache sind, macht den Unterschied zwischen einem Decompiler vertrauen und von ihm überrascht werden.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.