Was ist der Unterschied zwischen Value Types und Reference Types?

Question

Accepted Answer

C#-Typen fallen in zwei grundlegende Kategorien: **Value Types** (speichern die Daten direkt) und **Reference Types** (speichern eine Referenz/einen Zeiger auf Daten im Heap). Sie unterscheiden sich in der Speicherung, dem Kopieren und dem Vergleichen — eine entscheidende Unterscheidung, die das Verhalten in der gesamten Sprache beeinflusst.

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

Das Zuweisen eines Value Types kopiert die Daten (unabhängig); das Zuweisen eines Reference Types kopiert die Referenz (beide Namen zeigen auf das gleiche Objekt, also wirkt sich eine Mutation durch den einen auf den anderen aus).

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

## Warum es wichtig ist

Die Value-vs-Reference-Unterscheidung ist eines der grundlegendsten Konzepte in C# und erklärt eine breite Palette von Verhaltensweisen und Bugs — daher ist es wichtiges Wissen.

Zu verstehen, dass **Value Types** (Structs, Primitive wie int/double, Enums) nach Wert kopiert werden (unabhängige Kopien), während **Reference Types** (Klassen, Arrays, Strings) nach Referenz kopiert werden (beide Namen zeigen auf das gleiche Objekt), ist entscheidend, um vorherzusagen, wie sich Daten verhalten: Das Ändern einer Value-Type-Kopie beeinflusst das Original nicht, aber das Mutieren eines gemeinsamen Reference-Type-Objekts beeinflusst alle Referenzen darauf (eine häufige Quelle überraschender Bugs).

Diese Unterscheidung beeinflusst auch **Gleichheit** (`==` vergleicht Werte für Value Types, aber Referenzidentität für Reference Types standardmäßig), **Methodenargumente** (Value Types werden als Kopien übergeben, Referenzen von Reference Types werden nach Wert übergeben — also können Methoden ein übergebenes Objekt mutieren, aber nicht ein übergebenes int), und **Nullability** (nur Reference Types können null sein, es sei denn, ein Value Type wird mit `?` nullable gemacht).

Zu verstehen, welche Typen Value vs Reference sind und welche Kopier-, Vergleichs- und Mutationssemantik sich daraus ergibt, ist grundlegend für das Schreiben korrekten C#-Codes und für die Vermeidung der häufigsten konzeptionellen Fallstricke der Sprache — es ist die Grundlage, wie Daten durch ein Programm fließen, und ist ein häufiges Interviewthema genau deshalb, weil es offenbart, ob ein Entwickler C#s Typsystem wirklich versteht.