Boxing एक value type (जैसे int) को एक reference type (object) में परिवर्तित करना है — इसे heap पर एक object में wrap करना। Unboxing इसका उल्टा है (value को वापस निकालना)। दोनों में एक performance cost है (heap allocation, copying), और इन्हें समझना आपको अनावश्यक 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 heap पर एक नई object allocate करता है और value को इसमें copy करता है; unboxing इसे वापस बाहर copy करता है। प्रत्येक boxing operation एक heap allocation है — एक बार सस्ता, लेकिन hot paths या 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 अक्सर implicitly होता है — जब भी एक value type का उपयोग वहां किया जाता है जहां object (या एक non-generic interface) अपेक्षित होता है। loops या hot paths में, बार-बार boxing कई short-lived heap objects बनाता है, 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
मुख्य समाधान generics का उपयोग करना है (ArrayList के बजाय List<int>) — generics value types को boxing के बिना सीधे संग्रहीत करते हैं। यह पुराने non-generic collections पर generics के मुख्य performance लाभों में से एक है।
boxing और unboxing को समझना performant C# लिखने के लिए और यह सराहना करने के लिए महत्वपूर्ण है कि generics क्यों मायने रखते हैं।
Boxing — एक value type को एक reference type (object) में परिवर्तित करना — एक heap allocation और copy करता है, और unboxing value को वापस copy करता है, इसलिए दोनों में एक performance cost है।
हालांकि एक एकल boxing operation सस्ता है, समस्या यह है कि boxing अक्सर implicitly होता है (जब भी एक value type का उपयोग वहां किया जाता है जहां एक object अपेक्षित होता है) और loops या hot paths में बार-बार हो सकता है, कई short-lived heap objects बनाते हुए जो GC pressure बढ़ाते हैं और performance को गिराते हैं — एक सूक्ष्म, आसानी से छूट जाने वाला performance मुद्दा।
मुख्य व्यावहारिक निष्कर्ष यह है कि generics boxing से बचते हैं: पुराने non-generic ArrayList के बजाय List<int> का उपयोग value types को boxing के बिना सीधे संग्रहीत करता है, जो legacy non-generic collections पर generics के प्रमुख performance लाभों में से एक है (और हमेशा generic collections का उपयोग करने का एक मुख्य कारण)।
यह समझना कि boxing/unboxing क्या हैं, वे कब होते हैं (अक्सर अदृश्य रूप से), उनकी performance cost (allocation, GC pressure, विशेष रूप से loops में), और generics उन्हें कैसे रोकते हैं, कुशल C# लिखने और यह समझने के लिए महत्वपूर्ण ज्ञान है कि generic collections को क्यों पसंद किया जाता है।
चूंकि boxing performance overhead का एक सामान्य, सूक्ष्म स्रोत है, और चूंकि इससे बचना (generics के माध्यम से) एक मौलिक performance अभ्यास है, boxing/unboxing को समझना मूल्यवान, व्यावहारिक रूप से प्रासंगिक ज्ञान है जो performance-aware C# developers को अलग करता है और एक बारंबार interview विषय है जो value/reference type मॉडल और generics के लाभों की समझ दर्शाता है।