Skip to content
← Alle Beiträge
· Delta1 Labs BoxingGlass.NETDekompilierung.NETDeep Dive

Wie Boxing und Unboxing in C# dekompilieren

Eine implizite Konvertierung von int nach object ist in C# unsichtbar, alloziert aber auf dem Heap — und die IL sagt es deutlich mit einem box-Opcode. Dieser Beitrag zeigt, woher box, unbox.any und das constrained.-Präfix kommen, warum generischer Code constrained. nutzt, um einer Boxing-Allokation auszuweichen, und wie Glass.NET lesbares C# rekonstruiert, während die IL die Allokation offenlegt, die der Quelltext verbirgt.

Eine implizite Konvertierung von int nach object ist eines der leisesten teuren Dinge in C#. Sie schreiben object o = n; — kein Cast, keine Umstände — und eine Heap-Allokation geschieht. Das C# sagt nichts darüber. Die IL sagt alles darüber, in einem einzigen Opcode: box. Boxing, sein Gegenstück unbox.any und das constrained.-Präfix, das generischer Code nutzt, um Boxing zu vermeiden, sind eine kleine Familie von Instruktionen, die zusammen erklären, woher die versteckten Allokationen in .NET kommen. Sie veranschaulichen auch gut die Aufgabe eines Dekompilierers: Glass.NET gibt Ihnen das lesbare C# zurück, das der Autor geschrieben hat, und die IL-Ansicht gibt Ihnen die Allokation zurück, die der Autor nie getippt hat.

Glass.NET ist ein kostenloser .NET-Dekompilierer und Assembly-Inspektor, aufgebaut auf der ILSpy-Engine. Alles unten ist statische Analyse: Es liest die Metadaten und die Methodenrümpfe eines Assemblys, das Sie bereits besitzen; es lädt oder führt das Ziel niemals aus.

Der box-Opcode

Beginnen wir mit der denkbar einfachsten Boxing-Konvertierung:

public static object Wrap(int n) => n;

Der Rückgabetyp ist object und das Argument ist int, also muss eine Konvertierung stattfinden. In der IL ist sie explizit:

ldarg.0
box      [System.Runtime]System.Int32
ret

box nimmt den int vom Stack, alloziert einen geboxten Int32 auf dem verwalteten Heap und legt die Referenz ab. Das ist die ganze Geschichte des Boxing: Ein Werttyp wird in ein frisch alloziertes Objekt kopiert, damit ein referenztypisiertes Feld ihn aufnehmen kann. Derselbe Opcode erscheint bei einer Konvertierung zu einer Schnittstelle, die der Wert implementiert, zu System.ValueType, zu System.Enum oder zu dynamic — überall dort, wo ein Wert zu einer Referenz werden muss.

Glass.NET dekompiliert Wrap zurück zu return n;, was genau der Quelltext ist. Die Allokation ist in dieser Zeile nicht sichtbar, weil sie auch in der ursprünglichen Zeile nie sichtbar war. Schalten Sie dieselbe Methode auf die IL-Ansicht um, und das box Int32 steht genau dort: die eine Instruktion, die ein harmloses Return in eine Allokation verwandelt.

Unboxing ist ein Cast

Die umgekehrte Richtung ist ein Cast von object zurück zu einem Werttyp:

public static int Unwrap(object o) => (int)o;
ldarg.0
unbox.any [System.Runtime]System.Int32
ret

unbox.any ist die moderne, bequeme Form: Es extrahiert den int-Wert aus der Box und lässt ihn auf dem Stack liegen, wobei es InvalidCastException wirft, falls o nicht wirklich ein geboxter Int32 ist. Es entspricht dem älteren Paar unbox (das einen verwalteten Zeiger in die Box liefert, ohne zu kopieren) gefolgt von ldobj (das den Wert durch diesen Zeiger liest). In der dekompilierten Ausgabe sehen Sie meist unbox.any, weil der C#-Cast (int)o direkt darauf abgebildet wird; das blanke unbox taucht auf, wenn der Quelltext die Adresse eines geboxten Werts genommen oder ihn an Ort und Stelle mutiert hat. Ein Dekompilierer, der unbox.any Int32 liest, verwandelt es zurück in den (int)-Cast, aus dem es stammt.

Wo sich Boxing versteckt: string.Format

Die obigen Konvertierungen sind sichtbar, weil sich die Typen um eine Zeile unterscheiden. Boxing wird interessant, wenn es tief in einem Bibliotheksaufruf vergraben ist. Ein klassischer Fall ist eine zusammengesetzte Formatzeichenfolge:

public static string Line(int id, bool ok) =>
    string.Format("{0}:{1}", id, ok);

Hier bindet string.Format an die Überladung Format(string, object[]), also muss jedes der beiden werttypisierten Argumente zu einem object werden. Die IL baut das Array auf und boxt, während sie es füllt:

ldstr     "{0}:{1}"
ldc.i4.2
newarr    [System.Runtime]System.Object
dup
ldc.i4.0
ldarg.0
box       [System.Runtime]System.Int32      // id
stelem.ref
dup
ldc.i4.1
ldarg.1
box       [System.Runtime]System.Boolean    // ok
stelem.ref
call      string [System.Runtime]System.String::Format(string, object[])
ret

Eine Array-Allokation plus zwei Boxings für einen einzigen Formatierungsaufruf. Das dekompilierte C# ist der saubere Einzeiler, den Sie geschrieben haben; die Kosten stecken im newarr und in den beiden box-Opcodes darunter. Das zu sehen ist oft der erste Schritt zum Verständnis, warum ein heißer Logging-Pfad mehr alloziert, als es aussieht.

Der berühmte Fall: Enum.HasFlag

Enum.HasFlag ist die kanonische Überraschung. Seine Signatur nimmt ein System.Enum, das ein Referenztyp ist, also boxt der Aufruf auf einem werttypisierten Enum — zweimal:

[Flags] enum Access { Read = 1, Write = 2 }

public static bool CanWrite(Access a) => a.HasFlag(Access.Write);
ldarg.0
box       Access
ldc.i4.2
box       Access
call      instance bool [System.Runtime]System.Enum::HasFlag(class [System.Runtime]System.Enum)
ret

Der Empfänger a wird geboxt, und das Argument Access.Write wird geboxt. Der dekompilierte Quelltext ist das ordentliche a.HasFlag(Access.Write); die IL ist der Ort, an dem sich die beiden Allokationen selbst ankündigen. (Genau deshalb lautet der übliche Rat, in heißem Code (a & Access.Write) != 0 zu schreiben; und wenn Sie diese Version dekompilieren, sind die box-Opcodes einfach verschwunden, ersetzt durch ein and und einen Vergleich.)

Das constrained.-Präfix: Boxing, das Sie vermeiden können

Generischer Code steht vor einem Dilemma. Betrachten Sie:

public static string Describe<T>(T value) => value.ToString();

Zur Compilezeit weiß der Compiler nicht, ob T eine struct oder eine class sein wird. Würde er value immer boxen, um object.ToString() aufzurufen, würde jede struct allozieren. Würde er nie boxen, wären Referenztypen kaputt. Die Antwort der CLR ist das constrained.-Präfix, das die Entscheidung an den JIT verschiebt:

.method public static string Describe<T>(!!T value)
{
  ldarga.s   value           // die Adresse des Werts, keine Kopie
  constrained. !!T
  callvirt   instance string [System.Runtime]System.Object::ToString()
  ret
}

Beachten Sie ldarga: Es lädt die Adresse des Arguments, einen verwalteten Zeiger, statt des Werts. Das Präfix constrained. !!T sagt dem JIT dann, wie durch diesen Zeiger zu dispatchen ist, sobald T bekannt ist:

constrained. !!T + callvirtptr → T::ToString()was ist T zur Laufzeit?Werttyp, überschreibtcall T::ToString()direkter Aufruf — kein boxWerttyp, ohne Überschreibungbox T; callvirteine AllokationReferenztypldind.ref; callvirtdereferenzieren, dispatchenEin IL-Rumpf, drei JIT-Ergebnisse — das Präfix ist, wie generischer Code das Boxen einer struct vermeidet, die die Methode überschreibt.

So ruft Describe(new DateTime()) DateTime.ToString() direkt ohne Allokation auf, weil DateTime ToString überschreibt. Describe(someCustomStruct), das ToString nicht überschreibt, boxt einmal und ruft object.ToString() auf. Describe("hello") dereferenziert den Zeiger und führt einen gewöhnlichen virtuellen Aufruf aus. Ein IL-Methodenrumpf, drei vom JIT gewählte Verhaltensweisen — und der ganze Daseinszweck des Präfixes ist, den ersten Fall allokationsfrei zu halten.

Glass.NET rekonstruiert alle drei Fälle als dasselbe value.ToString(), weil das der Quelltext ist. Was die IL-Ansicht hinzufügt, ist das constrained. !!T-Präfix selbst, das Ihr Signal dafür ist, dass die Aufrufstelle generisch ist und dass es ganz vom konkreten T abhängt, ob sie alloziert. Das ist eine Unterscheidung, die Sie aus dem C# überhaupt nicht ablesen können.

Warum die beiden Ansichten zusammen zählen

Das Muster über alle vier Beispiele ist dasselbe. Das dekompilierte C# ist treu zu dem, was der Autor geschrieben hat: return n;, string.Format(...), a.HasFlag(...), value.ToString(). Keine dieser Zeilen erwähnt eine Allokation, weil die Sprache darauf ausgelegt ist, die Konvertierungen implizit zu machen. Die Allokationen leben eine Schicht tiefer, in box, in der Sequenz newarr/stelem.ref/box und im Dispatch, den constrained. auflöst. Ein Dekompilierer, der Ihnen nur das C# zeigte, würde genau das verbergen, was eine Werttyp-Konvertierung kostet.

Deshalb ist das Lesen der beiden Ansichten nebeneinander die nützliche Gewohnheit. Glass.NET rekonstruiert die Form, damit der Code lesbar ist; die IL-Ansicht behält die Opcodes wortgetreu, damit die Allokationen zählbar sind. Beide sind statische Lesarten desselben Assemblys (keine Ausführung, nichts instrumentiert), was dies zu einem sicheren Weg macht, kompilierten Code — Ihren eigenen oder fremden — auf Boxing zu prüfen, das Sie nicht beabsichtigt haben.

Fazit

Boxing ist in C# per Design unsichtbar und in IL aus Notwendigkeit explizit. box markiert jede Wert-zu-Referenz-Konvertierung, unbox.any markiert den Cast zurück, und das constrained.-Präfix ist der Mechanismus, der generischem Code erlaubt, einer Boxing-Allokation auszuweichen, wenn der konkrete Typ es zulässt. Wenn eine dekompilierte Methode allokationsfrei aussieht, Ihr Profiler aber widerspricht, öffnen Sie die IL-Ansicht in Glass.NET und zählen Sie die box-Opcodes: Der Quelltext hat sie verborgen, aber die IL konnte es nie.

Nebula.NET testen

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