Skip to content
← Alle Beiträge
· Delta1 Labs Glass.NETDecompilation.NETDeep Dive

allows ref struct dekompilieren: das gesamte Feature ist ein einziges Metadaten-Bit, und es fallen zu lassen verengt deinen Vertrag im Stillen

Die allows-ref-struct-Anti-Constraint aus C# 13 erzeugt keinerlei IL im Methodenrumpf. Sie lebt vollständig in einem Bit von GenericParameterAttributes (AllowByRefLike, 0x20) an einem generischen Parameter — sieh, wie Glass.NET es zurückliest.

Die meisten Features der Sprache C# hinterlassen eine Spur im Instruktionsstrom. Eine async-Methode wird zu einer Zustandsmaschine, die du Schritt für Schritt durchgehen kannst; ein yield return wird zu einem MoveNext mit einer Marke, zu der gesprungen wird; selbst ein using ist nur ein try/finally um ein Dispose. Ein Dekompiler verdient sein Geld, indem er diese Instruktionen liest und sie in die Syntax zurückfaltet, die sie erzeugt hat.

Die allows ref struct-Anti-Constraint aus C# 13 ist die gegenteilige Art von Feature. Sie erzeugt keinerlei IL im Methodenrumpf. Das gesamte Feature ist ein Bit in einer Metadaten-Tabelle, gesetzt an einem generischen Parameter. Das macht sie zu einem der saubersten überhaupt denkbaren Fallbeispiele dafür, warum ein Dekompiler Metadaten ebenso sorgfältig lesen muss wie Code — denn hier sagt der Code nichts, und ein Werkzeug, das nur Code liest, übergibt dir eine Quelle, die kompiliert, identisch läuft und still falsch ist. Dieser Beitrag geht die Konstruktion für Glass.NET durch, den kostenlosen .NET-Dekompiler.

Eine Anti-Constraint, keine Constraint

Eine normale generische Constraint fügt eine Anforderung hinzu. where T : IDisposable besagt, dass ein Typargument IDisposable implementieren muss; der Compiler erzwingt es, und die Metadaten halten es als Zeile in der Tabelle GenericParamConstraints fest, die auf den Typ IDisposable zeigt.

allows ref struct tut das Gegenteil. Jeder generische Parameter in .NET trägt eine unsichtbare, lang bestehende Anforderung: Sein Typargument darf keine ref struct sein (Span<T>, ReadOnlySpan<T> oder jede ref struct, die du deklarierst). Diese Regel existierte, weil ref structs stack-only-Lebensdauergarantien haben, die das Generics-System historisch nicht einhalten konnte. C# 13 und .NET 9 erlauben dir, diese Regel pro Parameter aufzuheben, indem du allows ref struct schreibst. Du fügst keine Anforderung hinzu — du entfernst ein Verbot. Deshalb heißt sie Anti-Constraint, und deshalb wird sie als Erlaubnis-Bit statt als Constraint-Zeile gespeichert.

Das C# und die IL, zu der es kompiliert

Hier ein kleiner, realistischer Einsatz: eine Pipeline, die jeden Parser akzeptiert — einschließlich eines ref-struct-Parsers, der eine Span<char> umhüllt — solange er ein Interface implementiert.

using System;

public interface ILineParser
{
    int Parse(ReadOnlySpan<char> line);
}

public static class Pipeline
{
    public static int Run<TParser>(TParser parser, ReadOnlySpan<char> input)
        where TParser : ILineParser, allows ref struct
    {
        return parser.Parse(input);
    }
}

Die Constraint-Liste lautet ILineParser, allows ref struct: eine echte Interface-Constraint, dann die Anti-Constraint. Die Interface-Constraint erlaubt dem Rumpf, parser.Parse(...) aufzurufen; die Anti-Constraint ist das, was einem Aufrufer später erlaubt, Run<MySpanParser>(...) zu schreiben, wobei MySpanParser eine ref struct ist, die ILineParser implementiert — selbst ein begleitendes Feature aus C# 13.

Nun die IL von Run. Der Rumpf ist ein gewöhnlicher eingeschränkter Interface-Aufruf:

.method public hidebysig static int32
        Run<byreflike (class ILineParser) TParser>(
            !!TParser parser,
            valuetype [System.Runtime]System.ReadOnlySpan`1<char> input) cil managed
{
  .maxstack  2
  ldarga.s   parser
  ldarg.1
  constrained. !!TParser
  callvirt   instance int32 ILineParser::Parse(
                 valuetype [System.Runtime]System.ReadOnlySpan`1<char>)
  ret
}

Lies den Rumpf, und nichts ist ungewöhnlich: die Adresse des Empfängers laden, das Argument laden, constrained. callvirt auf die Interface-Methode. Das ist dieselbe Instruktionssequenz, die du für where TParser : ILineParser ganz ohne Anti-Constraint erhalten würdest. Die einzige Spur des Features ist in der Signaturzeile der Methode — das Schlüsselwort byreflike am generischen Parameter TParser — und byreflike ist keine Instruktion. Es ist die ILAsm-Darstellung eines Flags.

where TParser : ILineParser, allows ref structeine Interface-Constraint, dann die Anti-Constraint — und sie landen an zwei verschiedenen StellenTabelle GenericParamConstraintsZeile → TypeRef: ILineParserGenericParameterAttributes (ein Byte)0x10x20x40x80x100x200x400x80AllowByRefLikeVarianz · class · struct · new() · ← ref-struct-Erlaubnis → · ungenutztIL des Methodenrumpfsconstrained. !!TParsercallvirt ILineParser::Parse(...) identisch mit oder ohne das Bit0x20 beim Dekompilieren fallen lassen → kompiliert noch,läuft noch — aber Run<MySpanParser>(...)kompiliert nicht mehr für Aufrufer

Ein Bit in GenericParameterAttributes

Jeder generische Parameter hat einen GenericParameterAttributes-Wert — ein kleines Bitfeld, das bereits Varianz (out/in) und die speziellen Constraints class, struct und new() kodierte. .NET 9 fügte ihm ein weiteres Flag hinzu:

// System.Reflection.GenericParameterAttributes
None                       = 0x0000,
Covariant                  = 0x0001,
Contravariant              = 0x0002,
ReferenceTypeConstraint    = 0x0004,  // where T : class
NotNullableValueTypeConstraint = 0x0008,  // where T : struct
DefaultConstructorConstraint   = 0x0010,  // where T : new()
AllowByRefLike             = 0x0020,  // where T : allows ref struct  (neu in .NET 9)

Für das Run-Beispiel ist der GenericParameterAttributes-Wert von TParser genau 0x0020: AllowByRefLike gesetzt, alles andere frei. Die ILineParser-Anforderung steht nicht in diesem Wert — sie ist eine eigene GenericParamConstraints-Zeile. Du kannst die Trennung per Reflection bestätigen:

var tp = typeof(Pipeline).GetMethod("Run")!.GetGenericArguments()[0];

tp.GenericParameterAttributes.HasFlag(GenericParameterAttributes.AllowByRefLike); // True
tp.GetGenericParameterConstraints();  // [ ILineParser ] — das Interface, nichts über ref struct

Die Anti-Constraint ist das eine, das Interface das andere, und sie stammen aus zwei verschiedenen Tabellen. Ein Dekompiler muss beide lesen und sie in der von C# geforderten Reihenfolge wieder zusammensetzen: echte Typ-Constraints zuerst, dann allows ref struct zuletzt.

Warum der identische Rumpf eine Falle ist

Das ist der Teil, der die Konstruktion einen ganzen Beitrag wert macht. Weil die IL des Rumpfs keine Spur des Features trägt, erzeugt ein Dekompiler, der nur zum Rekonstruieren von Instruktionen gebaut ist, eine Run-Methode, die einwandfrei kompiliert und läuft — und deren Signatur genau die ref-struct-Argumente verbietet, die das Original erlaubte. Nichts wirft eine Ausnahme. Nichts sieht falsch aus. Die Methode verlor einfach eine Fähigkeit, die vollständig in den Metadaten lebte.

Konkret: Gegeben die ursprüngliche Assembly, ist Run<MySpanParser>(parser, text) — mit MySpanParser als ref struct, die ILineParser implementiert — legal. Dekompiliere mit fallen gelassener Anti-Constraint, kompiliere neu, und dieselbe Aufrufstelle kompiliert nicht mehr, mit „MySpanParser must be a non-ref-struct type to be used as parameter TParser”. Für jeden, der dekompiliert, um die eigene Bibliothek zu verstehen, zwei Builds zu vergleichen oder Code, zu dem er berechtigt ist, neu auszurichten, ist das eine stille Verengung des Vertrags — die Art von Regression, die teuer zu bemerken ist, weil der Code, der sich änderte, der Code ist, der sich nicht änderte.

Was Glass.NET rekonstruiert

Glass.NET liest die Flags des generischen Parameters, nicht nur seinen Rumpf, sodass die Anti-Constraint den Hin- und Rückweg übersteht. Richte es auf den Typ:

glass decompile Pipeline.dll --type Pipeline --member Run
public static int Run<TParser>(TParser parser, ReadOnlySpan<char> input)
    where TParser : ILineParser, allows ref struct
{
    return parser.Parse(input);
}

Die Interface-Constraint und die Anti-Constraint kommen in der richtigen Reihenfolge zurück, und der Rumpf faltet das constrained. callvirt zurück zu parser.Parse(input). Um die Metadaten zu sehen, die Glass gelesen hat, um dorthin zu gelangen, lass es seine Arbeit zeigen:

glass decompile Pipeline.dll --type Pipeline --member Run --constraint-check
TParser
  GenericParameterAttributes = 0x0020  (AllowByRefLike)
  GenericParamConstraints:
    [0] ILineParser   (interface)
  => where TParser : ILineParser, allows ref struct

Diese Ausgabe stellt das rohe 0x0020 neben die erzeugte Klausel, sodass du überprüfen kannst, dass das Bit die Anti-Constraint ist und nicht etwa ein falsch gelesenes Werttyp-Flag. Füge --il hinzu, um die andere Hälfte der Geschichte zu bestätigen — dass der Rumpf unter der Signatur ein gewöhnlicher eingeschränkter Interface-Aufruf ist, ohne irgendetwas Feature-Spezifisches:

glass decompile Pipeline.dll --type Pipeline --member Run --il

Das IL-Panel zeigt byreflike am Parameter in der .method-Signaturzeile und darunter die schlichte constrained. callvirt-Sequenz. In der Avalonia-Oberfläche ist dieselbe Trennung auf einen Blick sichtbar: Der Knoten des generischen Parameters unter Run listet seine dekodierten Flags, und die synchronisierte IL-Ansicht hebt das Signatur-Schlüsselwort hervor, während der Rumpf keine Spur des Features trägt. Inspizierst du eine Abhängigkeit aus einem KI-Assistenten heraus, legt der MCP-Server dieselbe Rekonstruktion offen — glass mcp lässt den Assistenten glass_decompile aufrufen und die allows ref struct-Klausel selbst lesen, alles statische, nur-lesende Inspektion, ohne irgendetwas auszuführen.

Das Fazit

allows ref struct ist das seltene Feature mit null ausführbarem Fußabdruck. Der Compiler drückt es als einzelnes Bit aus — AllowByRefLike, 0x20 — an einem generischen Parameter und lässt den Methodenrumpf genau so, wie er ohne es wäre. Genau deshalb reicht das Lesen von Rümpfen nicht: Die treue Quelle lebt in den Metadaten, und ein Werkzeug, das das Flag ignoriert, übergibt dir Code, der kompiliert, genauso läuft und still die ref-struct-Argumente ablehnt, die der Autor bewusst erlaubt hat. Dieses eine Bit zurückzulesen und die Klausel an die richtige Stelle in der Constraint-Liste zu setzen, ist die ganze Arbeit — und es ist der Unterschied zwischen einer Quelle, die richtig aussieht, und einer, die richtig ist.

Glass.NET ist ein kostenloser .NET-Dekompiler mit einer Visual-Studio-nativen Avalonia-Oberfläche, einer CLI und einem MCP-Server. Lade es herunter und lies die Metadaten, die dein Compiler hinterlassen hat.

Nebula.NET testen

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