What are boxing and unboxing in C#? Where does hidden boxing happen, what does it cost, and how do you find and remove it?

1. What the runtime does on box

The IL box T instruction:

1. Allocates an object whose MethodTable is T's boxed MethodTable (every value type has one).
2. Copies the value's bytes into the object's field area.
3. Pushes the object reference.

Stack value: [42]
Heap box:    [header 8B][MethodTable* Int32 8B][42 4B][pad 4B]   = 24 bytes

unbox.any T:

1. Null check (unboxing null to a non-nullable value type throws NullReferenceException).
2. Checks the object's MethodTable is exactly T (or T's enum underlying type for enums — you can unbox a boxed enum to its underlying integer and vice versa).
3. Copies the value out.

That exact-type check is why (long)(object)42 throws: the box contains an Int32. You need (long)(int)o, or Convert.ToInt64(o).

2. Why generics avoid boxing

For value-type type arguments the JIT generates separate specialised native code per type: List<int> and List<double> each get their own code where T is the real type. A call like item.CompareTo(other) with where T : IComparable<T> is compiled as a direct (often inlined) call on the struct — no box.

For reference types, the JIT shares one implementation (__Canon) across all reference type arguments, using a dictionary lookup for type-specific information.

In IL, generic code uses the constrained. prefix before callvirt on a type parameter:

constrained. !!T
callvirt instance int32 [System.Runtime]System.IComparable`1<!!T>::CompareTo(!0)

The JIT resolves this per instantiation: for a struct that implements the method, it emits a direct call; only if the struct does not override a method inherited from object (e.g. ToString) does it need to box.

3. Struct overrides matter

public struct Sku { public int Id; }               // no overrides
public readonly record struct SkuR(int Id);        // generated overrides

Calling sku.ToString() or sku.GetHashCode() on Sku invokes ValueType's implementation, which needs this as an object — a box. ValueType.Equals(object) also boxes the argument and may use reflection. The record struct generates strongly typed Equals(SkuR), GetHashCode and ToString overrides, so no boxing.

4. JIT optimisations that remove boxing for you

Modern .NET removes many boxes automatically:

• Enum.HasFlag is an intrinsic since .NET Core 2.1 — no box.
• box immediately followed by unbox or isinst in generic code is folded.
• typeof(T) == typeof(int) checks in generics are compile-time constants per instantiation, enabling branch elimination.
• Escape analysis (.NET 9+) can stack-allocate boxes that do not escape the method, so object o = 5; return o.Equals(5); may allocate nothing.
• Interpolated string handlers (C# 10) call AppendFormatted<T>(T value) and check for ISpanFormattable without boxing.

So always measure: old "avoid X because it boxes" advice may be obsolete.

5. Boxing and mutation surprises

Because a box is a copy, mutating through an interface operates on the box, not the original:

struct Counter : IIncrement { public int Value; public void Increment() => Value++; }

var c = new Counter();
IIncrement i = c;   // box (copy)
i.Increment();      // increments the box
Console.WriteLine(c.Value);   // 0

This is another reason structs should be immutable.

6. Boxing in async and closures

Async state machines for methods that complete synchronously stay on the stack as structs. On the first real suspension, the state machine (a struct) is boxed to the heap (AsyncStateMachineBox<TStateMachine>). That box is expected and unavoidable for truly asynchronous work; ValueTask plus PoolingAsyncValueTaskMethodBuilder (.NET 6+) can pool those boxes on extremely hot paths.

7. Measuring with BenchmarkDotNet

[MemoryDiagnoser]
public class BoxingBench
{
    private readonly ArrayList _arrayList = new(Enumerable.Range(0, 1000).ToArray());
    private readonly List<int> _list = Enumerable.Range(0, 1000).ToList();

    [Benchmark] public int ArrayList() { int s = 0; foreach (object o in _arrayList) s += (int)o; return s; }
    [Benchmark] public int GenericList() { int s = 0; foreach (int x in _list) s += x; return s; }
}

The allocation column shows the enumerator allocation for ArrayList (its enumerator is a class) and zero for List<int>; adding to an ArrayList in a benchmark shows 24 bytes per element.

Try it yourself

1. Paste object o = 5; int x = (int)o; into SharpLab and find box and unbox.any.
2. Benchmark a Dictionary<MyStruct, int> lookup with and without IEquatable<MyStruct>.
3. Compare allocations of logger.LogInformation("{X}", x) vs a [LoggerMessage] method.
4. Reproduce the interface-mutation example and explain the output.

using System.Collections;
using Microsoft.Extensions.Logging;

namespace Types;

// Struct key with proper equality: no boxing in Dictionary lookups
public readonly struct SkuKey(int storeId, int productId) : IEquatable<SkuKey>
{
    public int StoreId { get; } = storeId;
    public int ProductId { get; } = productId;
    public bool Equals(SkuKey other) => StoreId == other.StoreId && ProductId == other.ProductId;
    public override bool Equals(object? obj) => obj is SkuKey k && Equals(k);
    public override int GetHashCode() => HashCode.Combine(StoreId, ProductId);
}

public static partial class Log
{
    // Source-generated logging: no params object[] and no boxing
    [LoggerMessage(Level = LogLevel.Debug, Message = "Request finished with {Status} in {ElapsedMs} ms")]
    public static partial void RequestFinished(ILogger logger, int status, double elapsedMs);
}

public static class Boxing
{
    public static void Main()
    {
        // Explicit box / unbox
        int n = 42;
        object o = n;                       // box
        int back = (int)o;                  // unbox
        long widened = (long)(int)o;        // unbox exact type, then convert
        Console.WriteLine($"{back} {widened}");

        // Hidden boxing with non-generic collections
        var legacy = new ArrayList { 1, 2, 3 };      // three boxes
        var modern = new List<int> { 1, 2, 3 };       // none
        Console.WriteLine(legacy.Count + modern.Count);

        // Generic constraint avoids boxing
        Console.WriteLine(Max(3, 7));

        // Struct keys with IEquatable<T>
        var stock = new Dictionary<SkuKey, int> { [new SkuKey(1, 100)] = 5 };
        Console.WriteLine(stock[new SkuKey(1, 100)]);
    }

    private static T Max<T>(T a, T b) where T : IComparable<T> => a.CompareTo(b) >= 0 ? a : b;
}