Qual è la differenza tra i tipi value e i tipi reference?

Question

Accepted Answer

I tipi C# si dividono in due categorie fondamentali: **tipi value** (memorizzano i dati direttamente) e **tipi reference** (memorizzano un riferimento/puntatore ai dati nello heap). Differiscono nel modo in cui vengono memorizzati, copiati e confrontati — una distinzione cruciale che influisce sul comportamento in tutto il linguaggio.

## Le due categorie

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

## La differenza chiave: semantica di copia

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

Assegnare un tipo value copia i dati (indipendenti); assegnare un tipo reference copia il riferimento (entrambi i nomi puntano allo stesso oggetto, quindi mutare tramite uno influisce sull'altro).

## Confronto e passaggio ai metodi

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

## Perché è importante

La distinzione value-vs-reference è uno dei concetti più fondamentali in C#, e spiega un'ampia gamma di comportamenti e bug — rendendola una conoscenza essenziale.

Comprendere che i **tipi value** (struct, primitive come int/double, enum) sono copiati per valore (copie indipendenti) mentre i **tipi reference** (class, array, string) sono copiati per riferimento (entrambi i nomi puntano allo stesso oggetto) è cruciale per prevedere il comportamento dei dati: modificare una copia di un tipo value non influisce sull'originale, ma mutare un oggetto di un tipo reference condiviso influisce su tutti i riferimenti ad esso (una fonte comune di bug sorprendenti).

Questa distinzione influisce anche sull'**uguaglianza** (`==` confronta i valori per i tipi value ma l'identità di riferimento per i tipi reference per impostazione predefinita), **gli argomenti dei metodi** (tipi value passati come copie, i riferimenti dei tipi reference passati per valore — così i metodi possono mutare un oggetto passato ma non un int passato), e **la nullabilità** (solo i tipi reference possono essere null, a meno che un tipo value non sia reso nullable con `?`).

Comprendere quali tipi sono value rispetto a reference e la conseguente semantica di copia, confronto e mutazione è fondamentale per scrivere C# corretto e evitare i concetti più comuni del linguaggio — sottende il modo in cui i dati fluiscono attraverso un programma ed è un argomento frequente nei colloqui proprio perché rivela se uno sviluppatore comprende veramente il sistema dei tipi di C#.