Jaka jest różnica między typami wartościowymi a typami referencyjnymi?

Question

Accepted Answer

Typy C# dzielą się na dwie fundamentalne kategorie: **typy wartościowe** (przechowują dane bezpośrednio) i **typy referencyjne** (przechowują referencję/wskaźnik do danych na stercie). Różnią się sposobem przechowywania, kopiowania i porównywania — to kluczowe rozróżnienie wpływające na zachowanie w całym języku.

## Dwie kategorie

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

## Kluczowa różnica: semantyka kopiowania

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

Przypisanie typu wartościowego kopiuje dane (niezależnie); przypisanie typu referencyjnego kopiuje referencję (obie nazwy wskazują na ten sam obiekt, więc mutacja poprzez jedną wpływa na drugą).

## Porównanie i przekazywanie do metod

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

## Dlaczego to ważne

Rozdział między wartościowymi i referencyjnymi to jedna z najbardziej fundamentalnych koncepcji w C#, wyjaśniająca szeroki zakres zachowań i błędów — czyniąc ją niezbędną wiedzą.

Zrozumienie, że **typy wartościowe** (struktury, prymitywy takie jak int/double, wyliczenia) są kopiowane przez wartość (niezależne kopie), podczas gdy **typy referencyjne** (klasy, tablice, ciągi znaków) są kopiowane przez referencję (obie nazwy wskazują na ten sam obiekt), jest kluczowe do przewidywania zachowania danych: modyfikacja kopii typu wartościowego nie wpływa na oryginał, ale mutacja współdzielonego obiektu typu referencyjnego wpływa na wszystkie referencje do niego (częste źródło zaskakujących błędów).

To rozróżnienie wpływa również na **równość** (`==` porównuje wartości dla typów wartościowych, ale tożsamość referencji dla typów referencyjnych domyślnie), **argumenty metod** (typy wartościowe przekazywane jako kopie, referencje typów referencyjnych przekazywane przez wartość — więc metody mogą mutować przekazany obiekt, ale nie przekazany int) i **nullowalność** (tylko typy referencyjne mogą być null, chyba że typ wartościowy jest nullowalny z `?`).

Zrozumienie, które typy są wartościowe a które referencyjne oraz wynikająca z tego semantyka kopiowania, porównywania i mutacji jest fundamentalne dla pisania poprawnego kodu C# i unikania najczęstszych pułapek koncepcyjnych języka — stanowi to podstawę tego, jak dane przepływają przez program i jest częstym tematem rozmów kwalifikacyjnych właśnie dlatego, że ujawnia, czy programista naprawdę rozumie system typów C#.