Boxing este conversia unui tip valoare (cum ar fi int) într-un tip referință (object) — înfășurând-o într-un obiect pe heap. Unboxing este operația inversă (extragerea valorii înapoi). Ambele au un cost de performanță (alocare pe heap, copiere), și înțelegerea lor te ajută să eviti overhead-ul needorit.
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 alocă un nou obiect pe heap și copiază valoarea în el; unboxing o copiază înapoi. Fiecare operație de boxing este o alocare pe heap — ieftină o singură dată, dar costisitoare în căi critice sau bucle.
// ❌ 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 se întâmplă adesea implicit — ori de câte ori un tip valoare este folosit acolo unde se așteaptă object (sau o interfață non-generică). În bucle sau căi critice, boxing-ul repetat creează multe obiecte pe heap cu viață scurtă, deteriorând performanța.
// ❌ 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
Principalul remediu este folosirea genericelor (List<int> în loc de ArrayList) — genericele stochează tipurile valoare direct fără boxing. Aceasta este unul dintre beneficiile cheie de performanță ale genericelor peste colecțiile vechi non-generice.
Înțelegerea boxing-ului și unboxing-ului este importantă pentru scrierea unui C# performant și pentru aprecierea motivului pentru care genericele sunt importante.
Boxing — conversia unui tip valoare într-un tip referință (object) — implică o alocare pe heap și copiere, iar unboxing copiază valoarea înapoi, deci ambele au un cost de performanță.
Deși o singură operație de boxing este ieftină, problema este că boxing se întâmplă adesea implicit (ori de câte ori un tip valoare este folosit acolo unde se așteaptă object) și poate apărea repetat în bucle sau căi critice, creând multe obiecte pe heap cu viață scurtă care cresc presiunea GC și degradează performanța — o problemă subtilă și ușor de ratat.
Principala concluzie practică este că genericele evită boxing-ul: folosirea List<int> în loc de vechia ArrayList non-generică stochează tipurile valoare direct fără boxing, ceea ce este unul dintre beneficiile majore de performanță ale genericelor peste colecțiile non-generice din trecut (și un motiv cheie pentru a folsi întotdeauna colecții generice).
Înțelegerea a ceea ce sunt boxing/unboxing, când se întâmplă (adesea invizibil), costul lor de performanță (alocare, presiune GC, mai ales în bucle) și cum genericele le previn este cunoaștere importantă pentru scrierea unui C# eficient și pentru înțelegerea motivului pentru care colecțiile generice sunt preferate.
Deoarece boxing este o sursă comună și subtilă de overhead de performanță, și deoarece evitarea lui (prin generice) este o practică fundamentală de performanță, înțelegerea boxing/unboxing este cunoaștere valoroasă și practic relevantă care deosebește dezvoltatorii C# conștienți de performanță și este un subiect frecvent în interviuri, reflectând înțelegerea modelului tip valoare/referință și beneficiile genericelor.