Boxing என்பது value type (like int) ஐ reference type (object) ஆக மாற்றுவது — heap இல் ஒரு object இல் wrap செய்வது. 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 செய்து மதிப்பை அதில் copy செய்கிறது; unboxing அதை மீண்டும் வெளியே copy செய்கிறது. ஒவ்வொரு boxing operation ஆனது heap allocation — ஒருமுறை cheap, ஆனால் hot paths அல்லது loops இல் costly.
// ❌ 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 இல், repeated 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
Main fix என்பது generics (List<int> ArrayList க்கு பதிலாக) பயன்படுத்துவது — generics value types ஐ directly store செய்கிறது boxing இல்லாமல். இது old non-generic collections க்கு மேல் generics இன் key performance benefits இல் ஒன்று.
Boxing மற்றும் unboxing ஐ புரிந்துகொள்வது performant C# எழுத பொருந்தக்கூடியது மற்றும் generics ஏன் முக்கியம் என்பதை வெளிப்படுத்த உதவுகிறது.
Boxing — value type ஐ reference type (object) ஆக மாற்றுவது — heap allocation மற்றும் copy உள்ளடக்கியது, மற்றும் unboxing மதிப்பை மீண்டும் copy செய்கிறது, எனவே இரண்டிற்கும் performance cost உண்டு.
ஒரு single boxing operation cheap என்றாலும், சிக்கல் என்பது boxing பெரும்பாலும் implicitly நிகழ்கிறது (value type ஆனது object எதிர்பார்க்கப்படும் இடத்தில் பயன்படுத்தப்படும்போது) மற்றும் loops அல்லது hot paths இல் repeatedly நிகழ்கலாம், பல short-lived heap objects ஐ உருவாக்கி GC pressure ஐ அதிகரிக்கிறது மற்றும் performance ஐ degrade செய்கிறது — ஒரு subtle, எளிதாக-miss செய்யக்கூடிய performance issue.
Key practical takeaway என்பது generics boxing ஐ தவிர்க்கிறது: List<int> ஐ old non-generic ArrayList க்கு பதிலாக பயன்படுத்துவது value types ஐ directly store செய்கிறது boxing இல்லாமல், இது legacy non-generic collections க்கு மேல் generics இன் major performance benefits இல் ஒன்று (மற்றும் எப்போதும் generic collections பயன்படுத்த key reason).
Boxing/unboxing என்றால் என்ன, அவை எப்போது நிகழ்கிறது (பெரும்பாலும் invisibly), அவற்றின் performance cost (allocation, GC pressure, especially loops இல்), மற்றும் generics அவற்றை எவ்வாறு தடுக்கிறது என்பது புரிந்துகொள்வது efficient C# எழுத முக்கியமான அறிவு மற்றும் value/reference type model மற்றும் generics' benefits ஐ புரிந்துகொள்ள உதவுகிறது.
Boxing ஒரு common, subtle source of performance overhead ஆக இருப்பதால், மற்றும் அதை தவிர்ப்பது (via generics) ஒரு fundamental performance practice ஆக இருப்பதால், boxing/unboxing ஐ புரிந்துகொள்வது valuable, practically-relevant அறிவு ஆக இருக்கிறது, அது performance-aware C# developers ஐ வேறுபடுத்துகிறது மற்றும் value/reference type model மற்றும் generics' benefits பற்றிய புரிதல் பிரதிபலிக்கும் ஒரு frequent interview topic ஆக இருக்கிறது.