Boxing yaiku ngubah value type (kaya int) menyang reference type (object) — melipur ing object ing heap. Unboxing yaiku kebalikan (ngomong nilai mbalik). Loro-lorone nduweni biaya performance (heap allocation, copying), lan ngerti bab iki ngewat sampeyan nyingkiri overhead sing ora perlu.
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 nggawe object anyar ing heap lan ngsalin nilai menyang nggon iku; unboxing ngsalin mbalik. Saben operasi boxing yaiku heap allocation — murah sakalèpak, nanging larang ing hot paths utawa 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 asring terjadi implisit — kapan-kapan value type dianggo ing ngendi object (utawa non-generic interface) dikarepaken. Ing loops utawa hot paths, boxing sing dibaleni-baleni nggawe akeh short-lived heap objects, ngerusak 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
Perbaikan utama yaiku nganggo generics (List<int> tinimbang ArrayList) — generics nyimpen value types langsung tanpa boxing. Iki yaiku salah siji kauntungan performance utama generics tinimbang non-generic collections lawas.
Ngerti boxing lan unboxing penting kanggo nulis C# sing performan lan kanggo ngerti kenapa generics penting.
Boxing — ngubah value type menyang reference type (object) — nggawe heap allocation lan copy, lan unboxing ngsalin nilai mbalik, mula loro-lorone nduweni biaya performance.
Sanajan operasi boxing tunggal iki murah, masalah yaiku boxing asring terjadi implisit (kapan-kapan value type dianggo ing ngendi object dikarepaken) lan bisa terjadi berulang ing loops utawa hot paths, nggawe akeh short-lived heap objects sing nambah GC pressure lan ngerusak performance — masalah performance sing subtle, gampang dilewati.
Nyata praktis utama yaiku generics nyingkiri boxing: nganggo List<int> tinimbang non-generic ArrayList lawas nyimpen value types langsung tanpa boxing, iki yaiku salah siji kauntungan performance gede generics tinimbang non-generic collections lawas (lan alasan utama tetep nganggo generic collections).
Ngerti apa boxing/unboxing, kapan iki terjadi (asring ora kasadaran), biaya performane (allocation, GC pressure, utamane ing loops), lan carane generics ngelis-ngelisi pengetahuan penting kanggo nulis C# sing efisien lan kanggo ngerti kenapa generic collections luwih dipilih.
Sanajan boxing yaiku sumber overhead performance sing umum lan subtle, lan sanajan nyingkiri (via generics) yaiku praktik performance fundamental, ngerti boxing/unboxing yaiku pengetahuan kanthi harkat, praktis-relevan sing mbedakake developers C# sing ngucapkan performance lan asring ditakon ing interview ngrembaka ngerti value/reference type model lan kauntungan generics.