Structs, copies and boxing

Lesson 1 showed that assigning a struct copies it. The surprises come from copies you did not write.

Boxing

A struct can be stored anywhere an object or an interface is expected. To do that, the runtime boxes it: allocates a heap object and copies the struct's bytes into it. From then on the box and the original are separate values.

1public interface ICounter2{3    void Increment();4    int Value { get; }5}6 7public struct Counter : ICounter8{9    public int Value { get; private set; }10    public void Increment() => Value++;11}12 13public class Holder14{15    private readonly Counter _counter;16 17    public int Bump()18    {19        _counter.Increment();20        _counter.Increment();21        return _counter.Value;22    }23}24 25public static class Solution26{27    public static string Describe()28    {29        var c = new Counter();30        ICounter boxed = c;          // boxing copies the struct onto the heap31        boxed.Increment();32        boxed.Increment();33 34        var h = new Holder();35        return $"local={c.Value} boxed={boxed.Value} readonlyField={h.Bump()}";36    }37}

boxed.Increment() ran twice, on the box; the local c never moved from 0. The Holder line is the subtler one: _counter is a readonly field, so the compiler must not let a method mutate it. It calls Increment on a defensive copy instead, every time, and the field stays 0. No warning, no exception: the writes just vanish. A readonly struct (all fields read-only) makes this impossible, which is the main reason to declare small structs that way.

Boxing also costs an allocation per value. Non-generic collections (ArrayList, Hashtable) box every int they store; List<int> does not, which was much of the point of generics.

Where a struct really lives

1public struct Stats2{3    public int Max;4    public Stats() { Max = int.MinValue; }5}6 7public static class Solution8{9    public static string Describe()10    {11        var made = new Stats();12        var arr = new Stats[2];13        var deflt = default(Stats);14 15        arr[0].Max = 7;                  // an array element is a variable: this writes in place16 17        var list = new List<Stats> { new Stats() };18        var copy = list[0];              // the List indexer hands back a copy19        copy.Max = 7;20 21        return $"new()={made.Max} array={arr[1].Max} default={deflt.Max} arr[0]={arr[0].Max} list[0]={list[0].Max}";22    }23}

Three facts in one run:

• new Stats() runs the parameterless constructor (allowed on structs since C# 10), so Max is int.MinValue. But new Stats[2] and default(Stats) do not run it; they are zeroed memory, so Max is 0. Any struct must be valid in its all-zero state.
• An array element is a variable: arr[0].Max = 7 writes into the array itself.
• A List<T> indexer is a method that returns a copy. Changing the copy leaves the list alone. (Writing list[0].Max = 7 directly does not even compile, error CS1612, precisely because it would be lost.)

Common mistakes

• Mutable structs. Every one of the silent copies above is harmless for an immutable struct and a bug for a mutable one. Prefer readonly struct and return new values.
• Comparing boxed values with ==. object a = 42, b = 42; gives a == b false (two boxes, compared by reference) and a.Equals(b) true:

1public static class Solution2{3    public static string Describe()4    {5        object a = 42;6        object b = 42;7        int x = 42;8        return $"a==b {a == b} | a.Equals(b) {a.Equals(b)} | (int)a==x {(int)a == x} | a is int n && n==x {(a is int n && n == x)}";9    }10}

• Trusting a struct constructor to run. Arrays, default, and uninitialised fields all skip it, as shown above.

What interviewers ask

• "What is boxing, and when does it happen?" Copying a value type into a heap object so it can be used as object or an interface: assigning a struct to an object or interface-typed variable, passing it where one is expected, storing it in a non-generic collection. Unboxing is the cast back, and copies again.
• "When would you choose a struct over a class?" Small (a few fields), logically a single value, usually immutable, and created in large numbers where avoiding heap allocations matters.
• "Why can't you write list[0].X = 5 for a List of structs?" The indexer returns a copy; the assignment would change a temporary, so the compiler rejects it. Read, modify, write back, or use an array.