What is the difference between value and reference types?

Question

Accepted Answer

C# types fall into two fundamental categories: **value types** (store the data directly) and **reference types** (store a reference/pointer to data on the heap). They differ in how they're stored, copied, and compared — a crucial distinction affecting behavior throughout the language.

## The two categories

```text
Value types     → struct, int, double, bool, char, enum, DateTime, decimal
                  Stored INLINE (stack for locals); copied BY VALUE.
Reference types → class, string, array, object, interface, delegate
                  Variable holds a REFERENCE to data on the heap; copied BY REFERENCE.
```

## The key difference: copy semantics

```csharp
// VALUE type — assignment COPIES the value (independent)
int a = 5;
int b = a;      // b is a COPY
b = 10;         // a is still 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // COPIES the whole struct
p2.X = 99;      // p1.X is still 1

// REFERENCE type — assignment copies the REFERENCE (both point to the SAME object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // both reference the SAME Box
box2.Value = 99;   // box1.Value is now 99 too!
```

Assigning a value type copies the data (independent); assigning a reference type copies the reference (both names point to the same object, so mutating through one affects the other).

## Comparison and passing to methods

```csharp
// == compares VALUES for value types, REFERENCES (identity) for reference types
string s1 = "hi"; // (string is special — == compares content)
Box b1 = new(), b2 = new();
b1 == b2;   // false — different objects (reference equality by default)

// methods get a COPY of value types, the reference (by value) for reference types
void Modify(Box b) { b.Value = 100; }   // affects the caller's object
void Modify(int x) { x = 100; }           // does NOT affect the caller's int
```

## null

```text
Reference types can be null (no object). Value types CANNOT be null
(unless made nullable: int? — a Nullable<int>).
```

## Why it matters

The value-vs-reference distinction is one of the most fundamental concepts in C#, and it explains a wide range of behaviors and bugs — making it essential knowledge.

Understanding that **value types** (structs, primitives like int/double, enums) are copied by value (independent copies) while **reference types** (classes, arrays, strings) are copied by reference (both names pointing to the same object) is crucial for predicting how data behaves: modifying a value-type copy doesn't affect the original, but mutating a shared reference-type object affects all references to it (a common source of surprising bugs).

This distinction also affects **equality** (`==` compares values for value types but reference identity for reference types by default), **method arguments** (value types passed as copies, reference types' references passed by value — so methods can mutate a passed object but not a passed int), and **nullability** (only reference types can be null, unless a value type is made nullable with `?`).

Understanding which types are value vs reference and the resulting copy, comparison, and mutation semantics is foundational for writing correct C# and avoiding the language's most common conceptual pitfalls — it underpins how data flows through a program and is a frequent interview topic precisely because it reveals whether a developer truly understands C#'s type system.