બોક્સિંગ એ વેલ્યુ ટાઈપ (જેમ કે int) ને રેફરન્સ ટાઈપ (object) માં રૂપાંતરિત કરવું છે — તેને હીપ પર ઑબ્જેક્ટમાં લપેટવું. અનબોક્સિંગ એ વિપરીત છે (વેલ્યુને પાછી કાઢવી). બંને પાસે પરફોર્મન્સ કોસ્ટ છે (હીપ એલોકેશન, કૉપિંગ), અને તેમને સમજવું તમને અનાવશ્યક ઓવરહેડ ટાળવામાં મદદ કરે છે.
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)
બોક્સિંગ હીપ પર નવો ઑબ્જેક્ટ એલોકેટ કરે છે અને વેલ્યુને તેમાં કૉપી કરે છે; અનબોક્સિંગ તેને પાછો કાઢે છે. પ્રત્યેક બોક્સિંગ ઓપરેશન એક હીપ એલોકેશન છે — એક વાર સસ્તું, પરંતુ હોટ પાથ્સ અથવા લૂપમાં મોંઘું.
// ❌ 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
બોક્સિંગ ઘણીવાર અંતર્નિહિત રીતે થાય છે — જ્યારે પણ વેલ્યુ ટાઈપ object (અથવા નોન-જેનેરિક ઇન્ટરફેસ) અપેક્ષિત હોય ત્યારે. લૂપમાં અથવા હોટ પાથમાં, વારંવાર બોક્સિંગ ઘણા ટૂંકા-જીવતા હીપ ઑબ્જેક્ટ્સ બનાવે છે, જે પરફોર્મન્સને નુકસાન પહોંચાડે છે.
// ❌ 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
મુખ્ય ઉપચાર જેનેરિક્સ (ArrayList ની જગાએ List<int>) ઉપયોગ કરવો છે — જેનેરિક્સ વેલ્યુ ટાઈપ્સને સીધું સંગ્રહ કરે છે બોક્સિંગ વિના. આ જેનેરિક્સના પુરાણી નોન-જેનેરિક કલેક્શનોમાં કી પરફોર્મન્સ બેનિફિટ છે.
বોક્સિંગ અને અનબોક્સિંગને સમજવું કાર્યક્ષમ C# લખવા અને જેનેરિક્સ શા માટે મહત્વપૂર્ણ છે તેની પ્રશંસા કરવા માટે જરૂરી છે.
બોક્સિંગ — વેલ્યુ ટાઈપને રેફરન્સ ટાઈપ (object) માં રૂપાંતર કરવું — હીપ એલોકેશન અને કૉપી માટે ખર્ચ કરે છે, અને અનબોક્સિંગ વેલ્યુને પાછો કૉપી કરે છે, તેથી બંને પાસે પરફોર્મન્સ કોસ્ટ છે.
જ્યારે એક બોક્સિંગ ઓપરેશન સસ્તું છે, પરંતુ સમસ્યા એ છે કે બોક્સિંગ ઘણીવાર અંતર્નિહિત થાય છે (જ્યારે પણ વેલ્યુ ટાઈપ object અપેક્ષિત હોય ત્યારે) અને લૂપ અથવા હોટ પાથમાં વારંવાર થઈ શકે છે, જે ઘણા ટૂંકા-જીવતા હીપ ઑબ્જેક્ટ્સ બનાવે છે જે GC દબાણ વધારે છે અને પરફોર્મન્સ ખરાબ કરે છે — એક સૂક્ષ્મ, સરળતાથી ચૂકી જતી પરફોર્મન્સ સમસ્યા.
મુખ્ય વ્યવહારિક નિષ્કર્ષ એ છે કે જેનેરિક્સ બોક્સિંગ ટાળે છે: પુરાણી નોન-જેનેરિક ArrayList ની જગાએ List<int> ઉપયોગ કરવું વેલ્યુ ટાઈપ્સને સીધું સંગ્રહ કરે છે બોક્સિંગ વિના, જે જેનેરિક્સના પુરાણી નોન-જેનેરિક કલેક્શનોમાં મુખ્ય પરફોર્મન્સ બેનિફિટ છે (અને હંમેશા જેનેરિક કલેક્શનો ઉપયોગ કરવાનું મુખ્ય કારણ).
બોક્સિંગ/અનબોક્સિંગ શું છે, તેઓ ક્યારે થાય છે (ઘણીવાર અદૃશ્ય રીતે), તેમની પરફોર્મન્સ કોસ્ટ (એલોકેશન, GC દબાણ, ખાસ કરીને લૂપમાં), અને જેનેરિક્સ કેવી રીતે તેમને રોકે છે તેને સમજવું કાર્યક્ષમ C# લખવા અને જેનેરિક્સ શા માટે પ્રાધાન્ય આપવામાં આવે છે તે સમજવા માટે મહત્વપૂર્ણ જ્ઞાન છે.
બોક્સિંગ પરફોર્મન્સ ઓવરહેડનો એક સામાન્ય, સૂક્ષ્મ સ્ત્રોત હોવાથી, અને તેને ટાળવું (જેનેરિક્સ દ્વારા) એક મૂળભૂત પરફોર્મન્સ અભ્યાસ હોવાથી, બોક્સિંગ/અનબોક્સિંગને સમજવું મૂલ્યવાન, વ્યવહારિક રીતે પ્રાસંગિક જ્ઞાન છે જે પરફોર્મન્સ-સચેત C# ડેવલપર્સને અલગ કરે છે અને વેલ્યુ/રેફરન્સ ટાઈપ મોડેલ અને જેનેરિક્સના લાભોની સમજણ પ્રતિબિંબિત કરતી વારંવાર ઇન્ટરવ્યુ ટોપિક છે.