Boxing is het omzetten van een value type (zoals int) naar een reference type (object) — het inpakken in een object op de heap. Unboxing is het omgekeerde (de waarde er weer uit halen). Beide hebben prestatiekosten (heap-allocatie, kopiëren), en als je ze begrijpt, kun je onnodige overhead voorkomen.
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 alloceert een nieuw object op de heap en kopieert de waarde erin; unboxing kopieert het er weer uit. Elke boxing-operatie is een heap-allocatie — goedkoop eenmalig, maar kostbaar in hot paths of loops.
// ❌ 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 gebeurt vaak impliciet — wanneer een value type wordt gebruikt waar object (of een niet-generieke interface) wordt verwacht. In loops of hot paths creëert herhaald boxing veel kortlevende heap-objecten, wat de prestaties schaadt.
// ❌ 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
De belangrijkste oplossing is het gebruik van generics (List<int> in plaats van ArrayList) — generics slaan value types rechtstreeks op zonder boxing. Dit is een van de belangrijkste prestatievoordelen van generics ten opzichte van de oude niet-generieke collections.
Inzicht in boxing en unboxing is belangrijk voor het schrijven van performante C# en voor het waarderen van waarom generics belangrijk zijn.
Boxing — het omzetten van een value type naar een reference type (object) — veroorzaakt een heap-allocatie en kopie, en unboxing kopieert de waarde terug, dus beide hebben prestatiekosten.
Hoewel een enkele boxing-operatie goedkoop is, is het probleem dat boxing vaak impliciet gebeurt (wanneer een value type wordt gebruikt waar een object wordt verwacht) en kan herhaaldelijk in loops of hot paths voorkomen, veel kortlevende heap-objecten creërend die GC-druk verhogen en de prestaties verslechteren — een subtiel, gemakkelijk over het hoofd gezien prestatieprobleem.
De belangrijkste praktische conclusie is dat generics boxing voorkomen: het gebruik van List<int> in plaats van de oude niet-generieke ArrayList slaat value types rechtstreeks op zonder boxing, wat een van de grote prestatievoordelen van generics ten opzichte van de legacy niet-generieke collections is (en een belangrijke reden om altijd generieke collections te gebruiken).
Inzicht in wat boxing/unboxing zijn, wanneer ze gebeuren (vaak onzichtbaar), hun prestatiekosten (allocatie, GC-druk, vooral in loops), en hoe generics ze voorkomen, is belangrijke kennis voor het schrijven van efficiënte C# en voor het begrijpen van waarom generieke collections de voorkeur hebben.
Omdat boxing een veelvoorkomende, subtiele bron van prestatieoverhead is, en omdat het voorkomen ervan (via generics) een fundamentele prestatiepraktijk is, is inzicht in boxing/unboxing waardevolle, praktisch relevante kennis die performance-bewuste C#-ontwikkelaars onderscheidt en een frequent geïnterviewd onderwerp is dat inzicht weerspiegelt in het value/reference type-model en de voordelen van generics.