Boxing ist das Konvertieren eines Werttyps (wie int) in einen Referenztyp (object) — das Verpacken in einem Objekt auf dem Heap. Unboxing ist das Gegenteil (das Extrahieren des Werts zurück). Beide haben Performanzkosten (Heap-Allokation, Kopieren), und das Verständnis dafür hilft, unnötige Mehrbelastung zu vermeiden.
int number = 42; // a value type (on the stack)
object boxed = number; // BOXING — wraps 42 in an object ON THE HEAP (allocation + copy)
int unboxed = (int)boxed; // UNBOXING — extracts the value back (copy, requires a cast)
Boxing allokiert ein neues Objekt auf dem Heap und kopiert den Wert hinein; Unboxing kopiert ihn zurück. Jede Boxing-Operation ist eine Heap-Allokation — einmal billig, aber kostspielig in Hot Paths oder Schleifen.
// ❌ using a value type where an `object` is expected → implicit boxing
object obj = 42; // boxing
ArrayList list = new(); list.Add(42); // boxes (non-generic — stores object)
string s = string.Format("{0}", 42); // boxing for the object[] params
// these can box repeatedly in loops → significant GC pressure
Boxing passiert häufig implizit — immer wenn ein Werttyp dort verwendet wird, wo object (oder eine nicht-generische Schnittstelle) erwartet wird. In Schleifen oder Hot Paths erzeugt wiederholtes Boxing viele kurzlebige Heap-Objekte und schadet der Performance.
// ❌ non-generic collection — boxes every value type added
ArrayList list = new();
list.Add(42); // boxes
// ✅ generic collection — NO boxing, type-safe
List<int> list = new();
list.Add(42); // no boxing — stored as int directly
Die Hauptlösung ist die Verwendung von Generics (List<int> statt ArrayList) — Generics speichern Werttypen direkt ohne Boxing. Dies ist einer der Hauptperformanzvorteile von Generics gegenüber den alten nicht-generischen Kolektionen.
Das Verständnis für Boxing und Unboxing ist wichtig, um performanten C#-Code zu schreiben und zu verstehen, warum Generics wichtig sind.
Boxing — das Konvertieren eines Werttyps in einen Referenztyp (object) — verursacht eine Heap-Allokation und Kopie, und Unboxing kopiert den Wert zurück, also haben beide Performanzkosten.
Während eine einzelne Boxing-Operation billig ist, liegt das Problem darin, dass Boxing oft implizit passiert (immer wenn ein Werttyp dort verwendet wird, wo ein object erwartet wird) und wiederholt in Schleifen oder Hot Paths auftreten kann, was viele kurzlebige Heap-Objekte erzeugt, die GC-Druck erhöhen und Performance beeinträchtigen — ein subtiles, leicht zu übersehendes Performance-Problem.
Die wichtigste praktische Erkenntnis ist, dass Generics Boxing vermeiden: Die Verwendung von List<int> statt der alten nicht-generischen ArrayList speichert Werttypen direkt ohne Boxing, was einer der Hauptperformanzvorteile von Generics gegenüber den veralteten nicht-generischen Kolektionen ist (und ein Hauptgrund, immer generische Kolektionen zu verwenden).
Das Verständnis, was Boxing/Unboxing sind, wann sie passieren (oft unsichtbar), ihre Performanzkosten (Allokation, GC-Druck, besonders in Schleifen) und wie Generics sie verhindern, ist wichtiges Wissen für das Schreiben von effizientem C# und für das Verständnis, warum generische Kolektionen bevorzugt werden.
Da Boxing eine häufige, subtile Quelle von Performance-Mehrbelastung ist und da es zu vermeiden (durch Generics) eine grundlegende Performance-Praxis ist, ist das Verständnis von Boxing/Unboxing wertvoll, praktisch relevantes Wissen, das performance-bewusste C#-Entwickler auszeichnet und ein häufiges Interviewthema ist, das das Verständnis des Werttyp/Referenztyp-Modells und der Vorteile von Generics widerspiegelt.