Vad är skillnaden mellan värdetyper och referenstyper?

Question

Accepted Answer

C#-typer faller in i två grundläggande kategorier: **värdetyper** (lagrar data direkt) och **referenstyper** (lagrar en referens/pekare till data på heapen). De skiljer sig åt i hur de lagras, kopieras och jämförs — en avgörande skillnad som påverkar beteendet genom hela språket.

## De två kategorierna

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

## Huvudskillnaden: kopierings-semantik

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

Att tilldela en värdetyp kopierar data (oberoende); att tilldela en referenstyp kopierar referensen (båda namn pekar på samma objekt, så en mutation genom ett påverkar det andra).

## Jämförelse och skicka till 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>).
```

## Varför det spelar roll

Skillnaden mellan värde och referens är ett av de mest grundläggande koncepten i C#, och det förklarar ett brett spektrum av beteenden och buggar — vilket gör det till essentiell kunskap.

Att förstå att **värdetyper** (structs, primitiver som int/double, enums) kopieras per värde (oberoende kopior) medan **referenstyper** (klasser, arrayer, strängar) kopieras per referens (båda namn pekar på samma objekt) är avgörande för att förutsäga hur data beter sig: att modifiera en värdetyp-kopia påverkar inte originalet, men att mutera ett delat referenstyp-objekt påverkar alla referenser till det (en vanlig källa till överraskande buggar).

Denna skillnad påverkar också **jämlikhet** (`==` jämför värden för värdetyper men referensidentitet för referenstyper som standard), **metod-argument** (värdetyper skickade som kopior, referenstypers referenser skickade per värde — så metoder kan mutera ett skickat objekt men inte ett skickat int), och **nullbar** (endast referenstyper kan vara null, om inte en värdetyp görs nullbar med `?`).

Att förstå vilka typer som är värde kontra referens och den resulterande kopierings-, jämförelse- och mutations-semantiken är grundläggande för att skriva korrekt C# och undvika språkets mest vanliga konceptuella fallgropar — det ligger till grund för hur data flödar genom ett program och är ett vanligt intervjuämne just för att det avslöjar om en utvecklare verkligen förstår C#:s typsystem.