Structs, value types and reference types

Two kinds of types

Every type in C# is either a value type or a reference type. The difference decides what happens when you copy a variable, pass it to a method, or compare it. Interviewers ask about this very often.

Seeing the difference

PointS s1 = new PointS { X = 1, Y = 2 };
PointS s2 = s1;          // copies the values
s2.X = 10;
Console.WriteLine(s1.X); // 1

PointC c1 = new PointC { X = 1, Y = 2 };
PointC c2 = c1;          // copies the reference
c2.X = 10;
Console.WriteLine(c1.X); // 10

struct PointS { public int X; public int Y; }
class PointC { public int X; public int Y; }

Stack and heap: the honest, simple version

You will hear "value types live on the stack, reference types live on the heap". It is a useful first picture but not the full truth. The stack is fast memory for a method's local variables; the heap is memory managed by the garbage collector. A local int usually sits on the stack. Every class object lives on the heap. But an int field inside a class object lives on the heap, inside that object. So think in terms of copy versus share, which is always true, rather than stack versus heap, which depends on where the value is stored.

Writing your own struct

var a = new Money(100m, "INR");
var b = a.Add(new Money(50.5m, "INR"));
Console.WriteLine(b);   // INR 150.50

public readonly struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency;
    }

    public Money Add(Money other) => new Money(Amount + other.Amount, Currency);
    public override string ToString() => $"{Currency} {Amount:F2}";
}

When to choose a struct

• It is small (a few numbers), roughly 16 bytes or less.
• It represents a single value, like a point, a money amount, a colour or a date.
• It is immutable (never changes after creation).
• It is created in very large numbers, where avoiding heap objects helps performance.

If any of these is false, use a class. Most of your types in business apps will be classes. C# also has record struct (module 5), which is often the easiest way to write a small value type.

Boxing and unboxing

Boxing happens when a value type is stored as object (or an interface): .NET makes a copy of it inside a new heap object, a "box". Unboxing is the cast back to the value type. It works, but it costs time and memory in hot loops. Generic collections like List<int> avoid boxing; the old ArrayList boxed every int.

int n = 42;
object boxed = n;          // boxing: a copy goes into a heap object
int back = (int)boxed;     // unboxing
n = 7;
Console.WriteLine(boxed);  // 42 (the box holds its own copy)

Equality

For classes, == checks whether two references point to the same object (unless the class defines its own ==, as string does). For your own structs, == does not compile until you write the operator yourself, while Equals compares the field values. Records (module 5) give you value equality for free.

Common mistakes and fixes

• Changing a struct inside a List: list[0].X = 5 is error CS1612, because list[0] returns a copy. Read it, change the copy, and store it back, or better, make the struct immutable.
• Big mutable structs passed around: every pass copies all the fields. Make it a class.
• Expecting a method to change a struct argument: it gets a copy. Return the new value instead.
• Thinking string is a value type because it behaves like one: string is a reference type that is immutable and compares by content.