Boxing är att konvertera en värdetyp (som int) till en referenstyp (object) — att omsluta den i ett objekt på heap-minnet. Unboxing är det omvända (att extrahera värdet tillbaka). Båda har en prestandakostnad (heap-allokering, kopiering), och att förstå dem hjälper dig att undvika onödig overhead.
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 allokerar ett nytt objekt på heap-minnet och kopierar värdet in i det; unboxing kopierar det tillbaka ut. Varje boxing-operation är en heap-allokering — billig en gång, men dyr i hot paths eller loopar.
// ❌ 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 sker ofta implicit — närhelst en värdetyp används där object (eller ett icke-generiskt gränssnitt) förväntas. I loopar eller hot paths skapar upprepad boxing många kortlivade heap-objekt, vilket skadar prestandan.
// ❌ 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
Huvudlösningen är att använda generics (List<int> istället för ArrayList) — generics lagrar värdetyper direkt utan boxing. Detta är en av de viktigaste prestandafördelarna med generics jämfört med de gamla icke-generiska samlingarna.
Att förstå boxing och unboxing är viktigt för att skriva performant C# och för att uppskatta varför generics är viktiga.
Boxing — att konvertera en värdetyp till en referenstyp (object) — medför en heap-allokering och kopiering, och unboxing kopierar värdet tillbaka, så båda har en prestandakostnad.
Even om en enstaka boxing-operation är billig är problemet att boxing ofta sker implicit (närhelst en värdetyp används där ett object förväntas) och kan inträffa upprepade gånger i loopar eller hot paths, vilket skapar många kortlivade heap-objekt som ökar GC-trycket och försämrar prestandan — ett subtilt, lätt att missa prestandaproblem.
Den viktigaste praktiska slutsatsen är att generics undviker boxing: att använda List<int> istället för det gamla icke-generiska ArrayList lagrar värdetyper direkt utan boxing, vilket är en av de största prestandafördelarna med generics jämfört med de äldre icke-generiska samlingarna (och en nyckelsak för att alltid använda generiska samlingar).
Att förstå vad boxing/unboxing är, när de sker (ofta osynligt), deras prestandakostnad (allokering, GC-tryck, särskilt i loopar) och hur generics förhindrar dem är viktig kunskap för att skriva effektiv C# och för att förstå varför generiska samlingar föredras.
Sinceboxing är en vanlig, subtil källa till prestandaöverhead, och eftersom man undviker det (via generics) är en grundläggande prestandapraxis, är förståelse för boxing/unboxing värdefull, praktiskt relevant kunskap som skiljer prestandamedvetna C#-utvecklare åt och är ett vanligt intervjuämne som återspeglar förståelse för värde-/referenstypmodellen och generics fördelar.