Wat is het verschil tussen value types en reference types?

Question

Accepted Answer

C# typen vallen in twee fundamentele categorieën: **value types** (slaan de gegevens direct op) en **reference types** (slaan een referentie/pointer naar gegevens op de heap op). Ze verschillen in hoe ze worden opgeslagen, gekopieerd en vergeleken — een cruciale onderscheiding die het gedrag in de hele taal beïnvloedt.

## De twee categorieën

```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.
```

## Het sleutelverschil: copy semantiek

```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!
```

Het toewijzen van een value type kopieert de gegevens (onafhankelijk); het toewijzen van een reference type kopieert de referentie (beide namen wijzen naar hetzelfde object, dus muteren via de ene beïnvloedt de ander).

## Vergelijking en doorgeven aan methoden

```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>).
```

## Waarom het belangrijk is

Het value-versus-reference onderscheid is een van de meest fundamentele concepten in C#, en het verklaart een breed scala aan gedragingen en bugs — waardoor het essentieel kennis is.

Begrijpen dat **value types** (structs, primitieven zoals int/double, enums) per waarde worden gekopieerd (onafhankelijke kopieën) terwijl **reference types** (klassen, arrays, strings) per referentie worden gekopieerd (beide namen wijzen naar hetzelfde object) is cruciaal voor het voorspellen hoe gegevens zich gedragen: het wijzigen van een value-type kopie beïnvloedt het origineel niet, maar het muteren van een gedeeld reference-type object beïnvloedt alle referenties ernaar (een veelvoorkomende bron van verrassende bugs).

Dit onderscheid beïnvloedt ook **gelijkheid** (`==` vergelijkt waarden voor value types maar referentie-identiteit voor reference types standaard), **methodeargumenten** (value types doorgegeven als kopieën, referenties van reference types per waarde doorgegeven — dus methoden kunnen een doorgegeven object muteren maar niet een doorgegeven int), en **nullability** (alleen reference types kunnen null zijn, tenzij een value type nullable wordt gemaakt met `?`).

Begrijpen welke typen value versus reference zijn en de resulterende copy-, vergelijkings- en mutatie-semantiek is fundamenteel voor het schrijven van correcte C# en het vermijden van de meest voorkomende conceptuele valkuilen van de taal — het onderbouwt hoe gegevens door een programma stromen en is een veelgezien interviewonderwerp precies omdat het onthult of een ontwikkelaar C#'s typesysteem werkelijk begrijpt.