📝 Lesson 4.1: The Memory Model: Value vs Reference

Two Kinds of Types

Every C# type is either a value type or a reference type, and that single fact drives how it's stored, copied, and compared.

Stack vs. Heap

.NET uses two memory regions:

• The stack — fast, automatically managed, per-thread. Holds local variables and method call frames; freed instantly when a method returns.
• The heap — where objects live. Managed by the garbage collector (GC), which reclaims objects no longer referenced (Lesson 4.3).

Copy Semantics

This is where the distinction bites. Assigning or passing a value type copies the data; the copy is independent:

struct PointStruct { public int X; public int Y; }

var a = new PointStruct { X = 1, Y = 2 };
var b = a;          // COPY — b is a separate PointStruct
b.X = 99;

Console.WriteLine(a.X);   // 1  — a is unaffected
Console.WriteLine(b.X);   // 99

Assigning a reference type copies the reference; both variables point to the same object:

class PointClass { public int X; public int Y; }

var c = new PointClass { X = 1, Y = 2 };
var d = c;          // COPY OF THE REFERENCE — same object
d.X = 99;

Console.WriteLine(c.X);   // 99  — c and d are the same object!
Console.WriteLine(d.X);   // 99

Boxing and Unboxing

Sometimes a value type needs to be treated as a reference type — for example, stored in an object or a non-generic collection. The runtime boxes it: wraps the value in a heap object. Extracting it back is unboxing.

int n = 42;
object boxed = n;        // BOXING — allocates a heap object holding 42
int back = (int)boxed;   // UNBOXING — copies the value back out

Choosing struct vs. class

Default to class. Reach for a struct only when the type genuinely models a small value and you'll benefit from value semantics or reduced allocations.

💡 The examples in .NET tell the story: int, DateTime, Guid, TimeSpan, and decimal are structs — small, immutable values. List<T>, string, and your entities are classes. When in doubt, choose class; a wrong struct choice is harder to undo.

Modern Struct Features

Modern C# adds tools for high-performance value types:

// Immutable value type — no defensive copies, safe to share by value
public readonly struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }
    public Money(decimal amount, string currency) => (Amount, Currency) = (amount, currency);
}

// Pass a big struct without copying it, using 'in'
static decimal Total(in Money a, in Money b) => a.Amount + b.Amount;

Exercise & Quiz

struct Vec { public int X, Y; }
class Node { public int Value; }

var v1 = new Vec { X = 1, Y = 1 };
var v2 = v1;      // copy
v2.X = 99;
Console.WriteLine($"v1.X={v1.X}, v2.X={v2.X}");   // TODO: predict then verify

var n1 = new Node { Value = 1 };
var n2 = n1;      // copy of reference
n2.Value = 99;
Console.WriteLine($"n1.Value={n1.Value}, n2.Value={n2.Value}");   // TODO: predict

// TODO: Move(Vec) vs Move(ref Vec); object[] boxing vs List<int>

struct Vec { public int X, Y; }
class Node { public int Value; }

var v1 = new Vec { X = 1, Y = 1 };
var v2 = v1;                 // independent copy
v2.X = 99;
Console.WriteLine($"v1.X={v1.X}, v2.X={v2.X}");     // v1.X=1, v2.X=99

var n1 = new Node { Value = 1 };
var n2 = n1;                 // same object
n2.Value = 99;
Console.WriteLine($"n1.Value={n1.Value}, n2.Value={n2.Value}"); // both 99

Move(v1);
Console.WriteLine($"after Move(copy): v1.X={v1.X}");      // 1 — unaffected
MoveRef(ref v1);
Console.WriteLine($"after Move(ref):  v1.X={v1.X}");      // 100 — changed

// Boxing vs no boxing
object[] boxed = { 1, 2, 3 };          // each int is boxed (3 heap allocations)
List<int> noBox = new() { 1, 2, 3 };   // stored as ints — no boxing
Console.WriteLine($"{boxed.Length} boxed, {noBox.Count} unboxed");

static void Move(Vec v) { v.X = 100; }             // mutates a copy
static void MoveRef(ref Vec v) { v.X = 100; }      // mutates the caller's Vec

Summary

📚 Additional Resources

• Value types — C# reference
• Choosing between class and struct
• Boxing and unboxing

🚀 What's Next?

You understand where data lives and how it's copied. Next, we use that to process data with zero extra allocations. In Lesson 4.2: Span and Memory, you'll slice arrays and buffers without copying them.