Quelle est la différence entre les types valeur et les types référence ?

Question

Accepted Answer

Les types C# se divisent en deux catégories fondamentales : les **types valeur** (stockent les données directement) et les **types référence** (stockent une référence/pointeur vers des données sur le tas). Ils diffèrent dans la façon dont ils sont stockés, copiés et comparés — une distinction cruciale qui affecte le comportement dans tout le langage.

## Les deux catégories

```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 différence clé : sémantique de copie

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

Assigner un type valeur copie les données (indépendant) ; assigner un type référence copie la référence (les deux noms pointent vers le même objet, donc muter via l'un affecte l'autre).

## Comparaison et passage aux méthodes

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

## Pourquoi c'est important

La distinction valeur-vs-référence est l'un des concepts les plus fondamentaux en C#, et elle explique un large éventail de comportements et de bugs — ce qui en rend la compréhension essentielle.

Comprendre que les **types valeur** (structs, primitives comme int/double, enums) sont copiés par valeur (copies indépendantes) tandis que les **types référence** (classes, arrays, strings) sont copiés par référence (les deux noms pointant vers le même objet) est crucial pour prédire le comportement des données : modifier une copie de type valeur n'affecte pas l'original, mais muter un objet type référence partagé affecte toutes les références vers lui (une source courante de bugs surprenants).

Cette distinction affecte aussi l'**égalité** (`==` compare les valeurs pour les types valeur mais l'identité de référence pour les types référence par défaut), les **arguments de méthode** (types valeur passés comme des copies, les références des types référence passées par valeur — donc les méthodes peuvent muter un objet passé mais pas un int passé), et la **nullabilité** (seuls les types référence peuvent être null, sauf si un type valeur est rendu nullable avec `?`).

Comprendre quels types sont valeur vs référence et les sémantiques de copie, comparaison et mutation qui en résultent est fondamental pour écrire du C# correct et éviter les pièges conceptuels les plus courants du langage — cela sous-tend la façon dont les données circulent dans un programme et est un sujet d'entretien fréquent précisément parce qu'il révèle si un développeur comprend véritablement le système de types de C#.