Boxing हा value type (जसे की int) ला reference type (object) मध्ये रूपांतरित करणे आहे — याला heap वर object मध्ये गुंडाळणे. Unboxing हा उलट आहे (मूल्य परत काढणे). दोन्हीला 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 करते आणि त्यात मूल्य कॉपी करते; unboxing त्याला परत बाहेर कॉपी करते. प्रत्येक 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 बर्याचदा implicit होते — जेव्हा 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 (List<int> ऐवजी ArrayList) वापरणे आहे — generics value types को boxing शिवाय थेट store करते. हा पुरातन non-generic collections पेक्षा generics चा मुख्य performance फायदा आहे.
Boxing आणि unboxing समजणे efficient C# लिहिण्यासाठी महत्वाचे आहे आणि generics का महत्वाचे आहे हे समजून घेण्यासाठी.
Boxing — value type ला reference type (object) मध्ये रूपांतरित करणे — heap allocation आणि copy मध्ये परिणमित होते, आणि unboxing मूल्य परत कॉपी करते, म्हणून दोन्हीला performance cost असते.
एक single boxing operation स्वस्त असला तरी, समस्या अशी आहे की boxing बर्याचदा implicit होते (जेव्हा value type असे वापरली जाते जिथे object अपेक्षित असते) आणि loops किंवा hot paths मध्ये वारंवार होऊ शकते, अनेक short-lived heap objects तयार करते जे GC pressure वाढवते आणि performance हरवते — हा subtile, सहज miss होणारा performance मुद्दा आहे.
मुख्य practical निष्कर्ष असा आहे की generics boxing टाळते: List<int> ऐवजी पुरातन non-generic ArrayList वापरल्याने value types boxing शिवाय थेट store होते, जो legacy non-generic collections पेक्षा generics चा प्रमुख performance फायदा आहे (आणि नेहमी generic collections वापरण्याचे मुख्य कारण आहे).
Boxing/unboxing म्हणजे काय, ते कधी होते (बर्याचदा अदृश्यपणे), त्यांचा performance cost (allocation, GC pressure, विशेषत: loops मध्ये), आणि generics त्यांना कसे रोखते हे समजणे efficient C# लिहिण्यासाठी महत्वाचे आहे आणि generic collections का प्राधान्य दिले जातात हे समजून घेण्यासाठी.
Boxing हा common, subtle source of performance overhead असल्यामुळे, आणि त्यास टाळणे (generics द्वारे) हा fundamental performance practice असल्यामुळे, boxing/unboxing समजणे मूल्यवान, practically-relevant ज्ञान आहे जो performance-aware C# developers ला वेगळे करते आणि value/reference type model आणि generics' benefits समजून घेणे दर्शविणारा वारंवार interview विषय आहे.