Hvad er forskellen mellem value types og reference types?

Question

Accepted Answer

C# typer falder i to grundlæggende kategorier: **value types** (gemmer dataene direkte) og **reference types** (gemmer en reference/pointer til data på heapen). De adskiller sig i, hvordan de lagres, kopieres og sammenlignes — en afgørende forskel, der påvirker opførslen i hele sproget.

## De to kategorier

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

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

Tildeling af en value type kopierer dataene (uafhængig); tildeling af en reference type kopierer referencen (begge navne peger på samme objekt, så mutation gennem det ene påvirker det andet).

## Sammenligning og passage til metoder

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

## Hvorfor det betyder noget

Value-vs-reference-skelnen er et af de mest fundamentale begreber i C#, og det forklarer en lang række opførsler og fejl — hvilket gør det til essentiel viden.

At forstå, at **value types** (structs, primitiver som int/double, enums) kopieres efter værdi (uafhængige kopier), mens **reference types** (classes, arrays, strings) kopieres efter reference (begge navne pegepå samme objekt), er afgørende for at forudsige, hvordan data opfører sig: ændring af en value-type kopi påvirker ikke originalen, men mutation af et delt reference-type objekt påvirker alle referencer til det (en almindelig kilde til overraskende fejl).

Denne skelnen påvirker også **lighed** (`==` sammenligner værdier for value types, men reference identity for reference types som standard), **metodeparametre** (value types sendt som kopier, reference types' referencer sendt efter værdi — så metoder kan mutere et sendt objekt, men ikke et sendt int), og **null-mulighed** (kun reference types kan være null, medmindre en value type gøres null-bar med `?`).

At forstå, hvilke typer der er value vs reference, og de resulterende kopi-, sammenlignings- og mutations-semantikker er grundlæggende for at skrive korrekt C# og undgå sprogets mest almindelige begrebsmæssige faldgruber — det danner grundlaget for, hvordan data strømmer gennem et program, og er et hyppigt interview-emne præcis fordi det afslører, om en udvikler virkelig forstår C#'s typesystem.