ਬਾਕਸਿੰਗ ਇੱਕ value type (ਜਿਵੇਂ int) ਨੂੰ ਇੱਕ reference type (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
ਬਾਕਸਿੰਗ ਅਕਸਰ ਬਿਨਾਂ ਸਪਸ਼ਟ ਸੰਕੇਤ ਦੇ ਹੁੰਦੀ ਹੈ — ਜਦੋਂ ਕਦੀ ਇੱਕ value type ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸਦੀ object (ਜਾਂ ਇੱਕ non-generic ਇੰਟਰਫੇਸ) ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਲੂਪਸ ਜਾਂ ਗਰਮ ਮਾਰਗਾਂ ਵਿੱਚ, ਦੁਹਰਾਈ ਗਈ ਬਾਕਸਿੰਗ ਬਹੁਤ ਸਾਰੇ ਥੋੜ੍ਹੇ ਜੀਆਂ ਵਾਲੇ ਹੀਪ ਆਬਜੈਕਟ ਬਣਾਉਂਦੀ ਹੈ, ਕਾਰਕਰਦਗੀ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾਂਦੀ ਹੈ।
// ❌ 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 ਨੂੰ ਬਿਨਾਂ ਬਾਕਸਿੰਗ ਦੇ ਸਿੱਧੇ ਤੌਰ ਤੇ ਸਟੋਰ ਕਰਦੇ ਹਨ। ਇਹ ਪੁਰਾਣੇ non-generic ਕਲੈਕਸ਼ਨਾਂ ਦੇ ਮੁਕਾਬਲੇ generics ਦਾ ਇੱਕ ਮੁੱਖ ਕਾਰਕਰਦਗੀ ਲਾਭ ਹੈ।
ਬਾਕਸਿੰਗ ਅਤੇ ਅਨਬਾਕਸਿੰਗ ਨੂੰ ਸਮਝਣਾ ਕੁਸ਼ਲ C# ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਅਤੇ ਇਸ ਦੀ ਸਮਝ ਹੈ ਕਿ generics ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹਨ।
ਬਾਕਸਿੰਗ — ਇੱਕ value type ਨੂੰ ਇੱਕ reference type (object) ਵਿੱਚ ਬਦਲਣਾ — ਹੀਪ ਅਲਾਕੇਸ਼ਨ ਅਤੇ ਕਾਪੀ ਦੀ ਸਹਤਾ ਕਰਦਾ ਹੈ, ਅਤੇ ਅਨਬਾਕਸਿੰਗ ਮੁੱਲ ਨੂੰ ਵਾਪਸ ਕਾਪੀ ਕਰਦੀ ਹੈ, ਇਸ ਲਈ ਦੋਵਿਆਂ ਦੀ ਕਾਰਕਰਦਗੀ ਲਾਗਤ ਹੈ।
ਜਦਕਿ ਇੱਕ ਸਿੰਗਲ ਬਾਕਸਿੰਗ ਓਪਰੇਸ਼ਨ ਸਸਤਾ ਹੈ, ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਬਾਕਸਿੰਗ ਅਕਸਰ ਬਿਨਾਂ ਸਪਸ਼ਟ ਸੰਕੇਤ ਦੇ ਹੁੰਦੀ ਹੈ (ਜਦੋਂ ਕਦੀ ਇੱਕ value type ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸਦੀ object ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ) ਅਤੇ ਲੂਪਸ ਜਾਂ ਗਰਮ ਮਾਰਗਾਂ ਵਿੱਚ ਵਾਰ ਵਾਰ ਹੋ ਸਕਦੀ ਹੈ, ਬਹੁਤ ਸਾਰੇ ਥੋੜ੍ਹੇ ਜੀਆਂ ਵਾਲੇ ਹੀਪ ਆਬਜੈਕਟ ਬਣਾਉਂਦੀ ਹੈ ਜੋ GC ਦਬਾਅ ਵਿੱਚ ਵਾਧਾ ਕਰਦੇ ਹਨ ਅਤੇ ਕਾਰਕਰਦਗੀ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ — ਇੱਕ ਸੂਖਮ, ਮਿਸ ਕਰਨ ਵਿੱਚ ਆਸਾਨ ਕਾਰਕਰਦਗੀ ਸਮੱਸਿਆ।
ਮੁੱਖ ਵਿਹਾਰਕ ਨਿਖੇੜ ਇਹ ਹੈ ਕਿ generics ਬਾਕਸਿੰਗ ਤੋਂ ਬਚਦੇ ਹਨ: ਪੁਰਾਣੇ non-generic ArrayList ਦੀ ਜਗ੍ਹਾ List<int> ਦੀ ਵਰਤੋਂ ਕਰਨਾ value types ਨੂੰ ਸਿੱਧੇ ਤੌਰ ਤੇ ਬਿਨਾਂ ਬਾਕਸਿੰਗ ਦੇ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਜੋ generics ਦਾ ਮੁੱਖ ਕਾਰਕਰਦਗੀ ਲਾਭ ਹੈ ਪੁਰਾਣੇ non-generic ਕਲੈਕਸ਼ਨਾਂ ਦੇ ਮੁਕਾਬਲੇ (ਅਤੇ ਹਮੇਸ਼ਾ ਆਮ ਕਲੈਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕਾਰਨ)।
ਯਾਦ ਰੱਖਣਾ ਕਿ ਬਾਕਸਿੰਗ/ਅਨਬਾਕਸਿੰਗ ਕੀ ਹਨ, ਜਦੋਂ ਉਹ ਹੁੰਦੀ ਹਨ (ਅਕਸਰ ਅਦਿੱਖ ਤੌਰ ਤੇ), ਉਨ੍ਹਾਂ ਦੀ ਕਾਰਕਰਦਗੀ ਲਾਗਤ (ਅਲਾਕੇਸ਼ਨ, GC ਦਬਾਅ, ਖਾਸ ਕਰਕੇ ਲੂਪਸ ਵਿੱਚ), ਅਤੇ generics ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਤੋਂ ਬਚਾਉਂਦੇ ਹਨ ਕੁਸ਼ਲ C# ਲਿਖਣ ਅਤੇ ਆਮ ਕਲੈਕਸ਼ਨਾਂ ਨੂੰ ਕਿਉਂ ਪਸੰਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇਸ ਨੂੰ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।
ਕਿਉਂਕਿ ਬਾਕਸਿੰਗ ਕਾਰਕਰਦਗੀ ਓਵਰਹੈੱਡ ਦਾ ਇੱਕ ਆਮ, ਸੂਖਮ ਸਰੋਤ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਇਸਤੋਂ ਬਚਣਾ (generics ਦੁਆਰਾ) ਇੱਕ ਬੁਨਿਆਦੀ ਕਾਰਕਰਦਗੀ ਅਭਿਆਸ ਹੈ, ਬਾਕਸਿੰਗ/ਅਨਬਾਕਸਿੰਗ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਵਿਹਾਰਕ-ਪ੍ਰਾਸੰਗਿਕ ਗਿਆਨ ਜੋ ਕਾਰਕਰਦਗੀ-ਜਾਗਰੂਕ C# ਡਿਵੈਲਪਰਸ ਨੂੰ ਅਲਗ ਕਰਦਾ ਹੈ ਅਤੇ ਵੈਲਿਊ/ਰੈਫਰੈਂਸ ਟਾਈਪ ਮਾਡਲ ਅਤੇ generics ਦੇ ਲਾਭਾਂ ਦੀ ਸਮਝ ਨੂੰ ਦਰਸਾਣ ਕਰਦੇ ਹੋਏ ਇੱਕ ਬਾਰ ਬਾਰ ਇੰਟਰਵਿਊ ਵਿਸ਼ਾ ਹੈ।