Boxing is converting a value type (like int) into a reference type (object) — wrapping it in an object on the heap. Unboxing is the reverse (extracting the value back). Both have a performance cost (heap allocation, copying), and understanding them helps you avoid unnecessary 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 allocates a new object on the heap and copies the value into it; unboxing copies it back out. Each boxing operation is a heap allocation — cheap once, but costly in hot paths or 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 often happens implicitly — whenever a value type is used where object (or a non-generic interface) is expected. In loops or hot paths, repeated boxing creates many short-lived heap objects, hurting 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
The main fix is using generics (List<int> instead of ArrayList) — generics store value types directly without boxing. This is one of the key performance benefits of generics over the old non-generic collections.
Understanding boxing and unboxing is important for writing performant C# and for appreciating why generics matter.
Boxing — converting a value type to a reference type (object) — incurs a heap allocation and copy, and unboxing copies the value back, so both have a performance cost.
While a single boxing operation is cheap, the problem is that boxing often happens implicitly (whenever a value type is used where an object is expected) and can occur repeatedly in loops or hot paths, creating many short-lived heap objects that increase GC pressure and degrade performance — a subtle, easy-to-miss performance issue.
The key practical takeaway is that generics avoid boxing: using List<int> instead of the old non-generic ArrayList stores value types directly without boxing, which is one of the major performance benefits of generics over the legacy non-generic collections (and a key reason to always use generic collections).
Understanding what boxing/unboxing are, when they happen (often invisibly), their performance cost (allocation, GC pressure, especially in loops), and how generics prevent them is important knowledge for writing efficient C# and for understanding why generic collections are preferred.
Since boxing is a common, subtle source of performance overhead, and since avoiding it (via generics) is a fundamental performance practice, understanding boxing/unboxing is valuable, practically-relevant knowledge that distinguishes performance-aware C# developers and is a frequent interview topic reflecting understanding of the value/reference type model and generics' benefits.