Boxing to konwersja typu wartościowego (takiego jak int) na typ referencyjny (object) — owijanie go w obiekt na stercie. Unboxing to proces odwrotny (wyodrębnienie wartości z powrotem). Oba procesy mają koszt wydajnościowy (alokacja na stercie, kopiowanie), a ich zrozumienie pomaga uniknąć niepotrzebnych narzutów.
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 przydzielić nowy obiekt na stercie i kopiuje wartość do niego; unboxing kopiuje ją z powrotem. Każda operacja boxingu to alokacja na stercie — tania pojedynczo, ale kosztowna w gorących ścieżkach lub pętlach.
// ❌ 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 często występuje niejawnie — zawsze, gdy typ wartościowy jest używany tam, gdzie oczekiwany jest object (lub interfejs niegeneryczny). W pętlach lub gorących ścieżkach powtarzane boxingi tworzą wiele krótkotrwałych obiektów na stercie, co wpływa negatywnie na wydajność.
// ❌ 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
Głównym rozwiązaniem jest użycie generyk (List<int> zamiast ArrayList) — generyki przechowują typy wartościowe bezpośrednio bez boxingu. To jest jedna z kluczowych korzyści wydajnościowych generyk w porównaniu ze starymi kolekcjami niegenerycznymi.
Zrozumienie boxingu i unboxingu jest ważne dla pisania wydajnego C# i do doceniania, dlaczego generyki mają znaczenie.
Boxing — konwersja typu wartościowego na typ referencyjny (object) — wiąże się z alokacją na stercie i kopią, a unboxing kopiuje wartość z powrotem, dlatego oba procesy mają koszt wydajnościowy.
Chociaż pojedyncza operacja boxingu jest tania, problem polega na tym, że boxing często występuje niejawnie (zawsze, gdy typ wartościowy jest używany tam, gdzie oczekiwany jest object) i może się powtarzać wielokrotnie w pętlach lub gorących ścieżkach, tworząc wiele krótkotrwałych obiektów na stercie, które zwiększają ciśnienie na garbage collector i pogorszają wydajność — to subtelny, łatwy do przeoczenia problem wydajnościowy.
Kluczowym praktycznym wnioskiem jest, że generyki unikają boxingu: użycie List<int> zamiast starej niegenerycznej ArrayList przechowuje typy wartościowe bezpośrednio bez boxingu, co jest jedną z głównych korzyści wydajnościowych generyk w stosunku do starszych kolekcji niegenerycznych (i głównym powodem, aby zawsze używać kolekcji generycznych).
Zrozumienie, czym są boxing/unboxing, kiedy się pojawiają (często niewidocznie), ich koszt wydajnościowy (alokacja, ciśnienie na GC, szczególnie w pętlach) i jak generyki je zapobiegają, to ważna wiedza dla pisania wydajnego C# i dla zrozumienia, dlaczego kolekcje generyczne są preferowane.
Ponieważ boxing jest częstym, subtelnym źródłem narzutu wydajnościowego, a unikanie go (poprzez generyki) jest fundamentalną praktyką wydajnościową, zrozumienie boxing/unboxing to cenna, praktycznie istotna wiedza, która odróżnia świadomych wydajności deweloperów C# i jest częstym tematem rozmów kwalifikacyjnych odzwierciedlającym zrozumienie modelu typów wartościowych/referencyjnych i korzyści generyk.