Mi a különbség az érték- és a referencia-típusok között?

Question

Accepted Answer

A C# típusok két alapvető kategóriára oszlanak: **érték-típusok** (az adatot közvetlenül tárolják) és **referencia-típusok** (hivatkozást/pointert tárolnak a heap-en lévő adatra). Abban különböznek, hogyan tárolódnak, másolódnak és hasonlítódnak össze — ez a lényeges különbség a nyelv viselkedését végighatározza.

## A két kategória

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

## A kulcskülönbség: másolási szemantika

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

Egy érték-típus hozzárendelése az adatot másolja (függetlenül); egy referencia-típus hozzárendelése a hivatkozást másolja (mindkét név ugyanarra az objektumra mutat, így az egyik módosítása a másikot is érinti).

## Összehasonlítás és átadás metódusoknak

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

## Miért fontos

Az érték-vs-referencia megkülönböztetés a C# egyik legfundamentálisabb koncepciója, és számos viselkedést és hibát magyaráz meg — így elengedhetetlen tudás.

Annak a megértése, hogy az **érték-típusok** (structs, primitívek, mint int/double, enumok) értékek szerinti másolódnak (független másolatok), míg a **referencia-típusok** (osztályok, tömbök, stringek) referencia szerinti másolódnak (mindkét név ugyanarra az objektumra mutat), döntő fontosságú az adatok viselkedésének megjóslásához: egy érték-típus kópia módosítása nem érinti az eredetit, de egy megosztott referencia-típus objektum mutálása az összes rá mutató hivatkozást érinti (a meglepetésszerű hibák gyakori forrása).

Ez a megkülönböztetés az **egyenlőséget** is érinti (`==` az érték-típusok esetén az értékeket, a referencia-típusoknál pedig alapértelmezésben a referencia-azonosságot hasonlítja össze), a **metódus-argumentumokat** (érték-típusok másolatként, referencia-típusok referenciái érték szerinti átadásként — így a metódusok egy átadott objektumot mutálhatnak, de egy átadott int-et nem), és a **nullability** (csak referencia-típusok lehetnek null, hacsak egy érték-típust nem teszünk nullázhatóvá a `?` segítségével).

Annak megértése, mely típusok érték-vs-referencia típusok és az ebből eredő másolás, összehasonlítás és mutálás szemantika, alapvető a helyes C# írásához és a nyelv leggyakoribb koncepcionális csapdáinak elkerüléséhez — ez alátámasztja, hogyan áramlik az adat egy programon keresztül, és gyakran megjelenő interjú téma, éppen azért, mert azt mutatja meg, a fejlesztő valóban érti-e a C# típusrendszerét.