C# Fundamentals — Value, Reference, Mutability

Core concepts that trip up even experienced developers. Master these and you’ll avoid a whole class of bugs.

1. Value Types vs Reference Types

The Memory Difference

	Value Types	Reference Types
Stored in	Stack (usually)	Heap
Examples	`int`, `bool`, `double`, `DateTime`, `struct`, `enum`	`class`, `string`, `array`, `List<T>`, `delegate`, `record`
Default value	`0`, `false`, etc.	`null`
Assignment	Copies the value	Copies the reference (pointer)
Equality	Compares values (`a == b` means same data)	Compares references (`a == b` means same object, unless `Equals` is overridden)

// Value Type
int a = 5;
int b = a;   // b gets a COPY of 5
a = 10;
Console.WriteLine(b); // Still 5 — independent!
 
// Reference Type
var list1 = new List<int> { 1, 2, 3 };
var list2 = list1;      // list2 points to the SAME list
list1.Add(4);
Console.WriteLine(list2.Count); // 4 — same object!

🧠 Key insight: Think of reference type variables as remote controls. When you assign b = a, you’re not giving b a new TV — you’re giving them a second remote that controls the same TV.

Nullability

int x = null;        // ❌ Compile error — value types can't be null (normally)
int? y = null;       // ✅ Nullable<int> — special wrapper for value types
string s = null;     // ✅ Reference types can be null by default
string? t = null;    // ✅ With nullable enabled, same thing (warns if not handled)

2. Pass by Value vs Pass by Reference

This is the most misunderstood concept in C#. Let’s be precise.

Value Types — Pass by Value (Default)

void Update(int x) {
    x = 10;  // Only changes the LOCAL copy
}
 
int a = 5;
Update(a);
Console.WriteLine(a); // 5 — unchanged!

A copy of the value is passed. The original variable is untouched.

Reference Types — Pass by Value (Default)

This is where everyone gets confused. The reference itself is passed by value.

void ModifyObject(Person p) {
    p.Name = "New";  // ✅ Modifies the original object
}
 
void ReassignObject(Person p) {
    p = new Person("Different");  // ❌ Only changes LOCAL copy of the reference
}
 
var person = new Person("Original");
ModifyObject(person);
Console.WriteLine(person.Name); // "New" ✅
 
ReassignObject(person);
Console.WriteLine(person.Name); // Still "New" — the reassignment didn't work!

🧠 The mental model:

Before ModifyObject():
    person ──▶ { Name: "Original" }
    p (copy) ──▶ { Name: "Original" }  ← Same object, different remote

After ModifyObject():
    person ──▶ { Name: "New" }         ← Changed via the remote
    p (copy) ──▶ { Name: "New" }

After ReassignObject():
    person ──▶ { Name: "New" }         ← Still points to the same object
    p (copy) ──▶ { Name: "Different" } ← p now points to a NEW object
                                          but person doesn't know!

Pass by Reference — The `ref` Keyword (Both Types)

void UpdateRef(ref int x) {
    x = 10;  // ✅ Changes the ORIGINAL variable
}
 
void ReassignRef(ref Person p) {
    p = new Person("Different");  // ✅ Changes the ORIGINAL reference
}
 
int a = 5;
UpdateRef(ref a);
Console.WriteLine(a); // 10 — the original was changed!
 
var person = new Person("Original");
ReassignRef(ref person);
Console.WriteLine(person.Name); // "Different" — the original reference was changed!

ref passes the actual variable slot — not a copy. Think of it as giving someone the address of your garage instead of a copy of your car keys.

Other Modifiers

Keyword	What it does	Direction
`ref`	Pass the original variable (in/out)	Both directions
`out`	Pass the original variable (must assign)	Output only
`in`	Pass a read-only reference	Input only

void GetValues(out int sum, out int count) {
    sum = 10;    // Must assign
    count = 5;   // Must assign
}

Quick Reference Table

Scenario	Can modify the object?	Can reassign the variable?
Value type (no ref)	N/A (it’s a copy)	❌ Only local
Value type (`ref`)	N/A	✅ Original
Reference type (no ref)	✅ Yes	❌ Only local
Reference type (`ref`)	✅ Yes	✅ Original

3. Mutable vs Immutable

Mutable — Can Change

Most C# objects are mutable by default:

var list = new List<int> { 1, 2, 3 };
list.Add(4);         // ✅ Same list, new item
list[0] = 99;        // ✅ Same list, changed value
 
var person = new Person();
person.Name = "New"; // ✅ Same object, changed property

Immutable — Cannot Change

Once created, the object’s state never changes. Any operation that “changes” it creates a new object.

// string is immutable
string s = "Hello";
string s2 = s.ToUpper();  // ✅ Creates NEW string "HELLO"
Console.WriteLine(s);     // Still "Hello" — original unchanged!
 
// Every "change" to a string creates a new string in memory
string result = "";
for (int i = 0; i < 1000; i++) {
    result += i.ToString();  // ❌ Creates 1000 temporary strings!
}
// Use StringBuilder instead:
var sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.Append(i);  // ✅ Modifies the SAME buffer
}

Immutable Types in C#

Type	Immutable?	Notes
`string`	✅ Yes	Every operation returns a new string
`int`, `bool`, `DateTime`	✅ Yes	Value types — “changing” replaces the value
`record` with `init`	✅ Yes	Can only set during initialization
`ReadOnlyCollection<T>`	✅ Yes	Cannot add/remove items
`StringBuilder`	❌ No	Designed for mutation
`List<T>`, `Dictionary<K,V>`	❌ No	Fully mutable
`Array`	❌ No	Can change elements, but can’t resize
`class` (yours)	❌ Usually	Mutable by default unless you design it otherwise

Creating Immutable Types

// 1. record with init (C# 9+)
public record Person(string Name, int Age);
// Usage: var p = new Person("Alice", 30);
// Cannot: p.Name = "Bob"; ❌
 
// 2. readonly struct
public readonly struct Point {
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}
 
// 3. Class with private setters
public class Configuration {
    public string ConnectionString { get; }  // No setter — can only set in constructor
    public Configuration(string cs) {
        ConnectionString = cs;
    }
}

Why Does Mutability Matter?

Scenario	Mutable Problem	Immutable Fix
Concurrency	Two threads modify same object → race condition	Thread-safe: nobody can change it
Caching	Someone modifies cached object → corrupted cache	Safe to cache and share
Debugging	Object changes unexpectedly → “who changed my data?”	Object always stays the same
Dictionaries	Object used as key gets its hash code changed → key lost	Safe to use as dictionary key

4. Common Interview Questions

Q: “Does `string` behave like a value type or reference type?”

Answer: string is a reference type that behaves like a value type. The reference is on the heap, but its immutability makes it act like a value — every “change” creates a new instance.

string a = "Hello";
string b = a;      // b points to the SAME "Hello"
a += " World";     // Creates NEW string "Hello World"
Console.WriteLine(b); // Still "Hello" — a now points elsewhere

Q: “What happens when you pass `List<T>` to a method?”

Answer: The reference is passed by value. The method gets a copy of the pointer, so it can modify the original list’s contents (add/remove/change items) but cannot reassign the original variable to a new list.

void Evil(List<int> list) {
    list.Clear();       // ✅ Original list is now empty!
    list = new List<int> { 99 };  // ❌ Only local, original unchanged
}

Q: “Why is `StringBuilder` faster than string concatenation?”

Answer: string is immutable. Every += creates a new string object with the combined text, copying both strings into new memory. That’s O(n²) time and creates many temporary objects for GC. StringBuilder maintains an internal mutable buffer (like a List<char>) and only creates the final string once, giving O(n) performance.

📊 Cheat Sheet

                ┌─────────────────────────────────────┐
                │         Passed to Method             │
                ├──────────────┬──────────────────────┤
                │  Without ref │     With ref          │
┌───────────────┼──────────────┼──────────────────────┤
│ Value Type     │ Copy of val  │ Original variable     │
│ (int, struct)  │ Can't modify │ Can modify directly   │
├───────────────┼──────────────┼──────────────────────┤
│ Reference Type │ Copy of ref  │ Original reference    │
│ (class, list)  │ Can modify   │ Can modify + REASSIGN │
│                │ object ✅    │ object + variable ✅  │
│                │ Can't REASSIGN ❌ │                   │
└───────────────┴──────────────┴──────────────────────┘

Mutable:   stringBuilder, List, Dictionary, Array, class
Immutable: string, int, bool, DateTime, record (init), ReadOnlyCollection

Related:

description	C# fundamentals every .NET developer should know — value types vs reference types, pass by value vs pass by reference, and mutable vs immutable objects.
tags	csharp, dotnet, fundamentals, interview-prep

🧠 Second Brain — Digital Garden

Explorer

C# Fundamentals — Value, Reference, Mutability

1. Value Types vs Reference Types

The Memory Difference

Nullability

2. Pass by Value vs Pass by Reference

Value Types — Pass by Value (Default)

Reference Types — Pass by Value (Default)

Pass by Reference — The `ref` Keyword (Both Types)

Other Modifiers

Quick Reference Table

3. Mutable vs Immutable

Mutable — Can Change

Immutable — Cannot Change

Immutable Types in C#

Creating Immutable Types

Why Does Mutability Matter?

4. Common Interview Questions

Q: “Does `string` behave like a value type or reference type?”

Q: “What happens when you pass `List<T>` to a method?”

Q: “Why is `StringBuilder` faster than string concatenation?”

📊 Cheat Sheet

Graph View

Table of Contents

🧠 Second Brain — Digital Garden

Explorer

C# Fundamentals — Value, Reference, Mutability

1. Value Types vs Reference Types

The Memory Difference

Nullability

2. Pass by Value vs Pass by Reference

Value Types — Pass by Value (Default)

Reference Types — Pass by Value (Default)

Pass by Reference — The ref Keyword (Both Types)

Other Modifiers

Quick Reference Table

3. Mutable vs Immutable

Mutable — Can Change

Immutable — Cannot Change

Immutable Types in C#

Creating Immutable Types

Why Does Mutability Matter?

4. Common Interview Questions

Q: “Does string behave like a value type or reference type?”

Q: “What happens when you pass List<T> to a method?”

Q: “Why is StringBuilder faster than string concatenation?”

📊 Cheat Sheet

Graph View

Table of Contents

Pass by Reference — The `ref` Keyword (Both Types)

Q: “Does `string` behave like a value type or reference type?”

Q: “What happens when you pass `List<T>` to a method?”

Q: “Why is `StringBuilder` faster than string concatenation?”