Care este diferența dintre tipurile de valori și tipurile de referință?

Question

Accepted Answer

Tipurile C# se încadrează în două categorii fundamentale: **tipurile de valori** (stochează datele direct) și **tipurile de referință** (stochează o referință/pointer la date pe heap). Ele diferă în modul în care sunt stocate, copiate și comparate — o distincție crucială care afectează comportamentul în toată limba.

## Cele două categorii

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

## Diferența cheie: semantica copierii

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

Atribuirea unui tip de valoare copiază datele (independent); atribuirea unui tip de referință copiază referința (ambele nume indică același obiect, deci mutarea prin una afectează cealaltă).

## Comparație și transmitere la metode

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

## De ce este important

Distincția dintre valori și referințe este unul dintre conceptele cele mai fundamentale în C#, și explică o gamă largă de comportamente și erori — ceea ce o face cunoștințe esențiale.

Înțelegerea că **tipurile de valori** (structs, primitive cum ar fi int/double, enums) sunt copiate după valoare (copii independente), în timp ce **tipurile de referință** (clase, tablouri, șiruri) sunt copiate după referință (ambele nume indicând același obiect) este crucială pentru a prezice cum se comportă datele: modificarea unei copii de tip valoare nu afectează originalul, dar mutarea unui obiect de tip referință partajat afectează toate referințele la acesta (o sursă comună de erori surprinzătoare).

Această distincție afectează, de asemenea, **egalitatea** (`==` compară valorile pentru tipurile de valori, dar identitatea referinței pentru tipurile de referință în mod implicit), **argumentele metodei** (tipurile de valori transmise ca copii, referințele tipurilor de referință transmise după valoare — deci metodele pot muta un obiect transmis, dar nu un int transmis), și **nullabilitatea** (doar tipurile de referință pot fi null, dacă un tip de valoare nu este făcut nullable cu `?`).

Înțelegerea care tipuri sunt valori vs referință și semantica rezultată a copierii, comparației și mutației este fundamentală pentru a scrie C# corect și a evita cele mai comune capcane conceptuale ale limbii — ea stă la baza modului în care datele circulă printr-un program și este un subiect frecvent la interviuri tocmai pentru că arată dacă un dezvoltator înțelege cu adevărat sistemul de tipuri al C#.