C# : La mémoire

Quand tu écris int age = 22; ou Voiture v = new Voiture();, où est-ce que ces données vivent ? Comment C# décide quoi stocker où ?

Comprendre la mémoire, c'est comprendre pourquoi le code se comporte comme il le fait - notamment la différence entre copier une valeur et copier une référence.

# Les deux zones mémoire

Un programme C# utilise deux zones de mémoire distinctes, chacune avec son rôle :

La Stack (pile)

La stack est une zone rapide, ordonnée et automatique. Elle fonctionne comme une pile d'assiettes : on empile en haut, on dépile en haut (LIFO - Last In, First Out).

Ce qu'elle stocke :

• Les variables locales des méthodes (paramètres, variables déclarées dans le corps)
• Les types valeur (int, bool, double, struct, enum...)
• Les références vers les objets du heap (l'adresse, pas l'objet lui-même)

Quand une méthode est appelée, un stack frame est empilé avec toutes ses variables locales. Quand la méthode se termine, le frame est dépilé - les variables sont supprimées automatiquement. Pas besoin de nettoyage manuel.

Le Heap (tas)

Le heap est une zone plus grande, plus lente et non ordonnée. C'est là que vivent les objets créés avec new.

Ce qu'il stocke :

• Les instances de classes (new Voiture(), new List<int>())
• Les strings (même si elles ressemblent à des types simples)
• Les tableaux (int[], string[])
• Tout ce qui est un type référence

Le heap n'a pas d'ordre - les objets sont placés là où il y a de la place. Et contrairement à la stack, les objets du heap ne sont pas automatiquement supprimés quand une méthode se termine. C'est le garbage collector qui s'en charge.

# Value types vs Reference types

C'est la distinction la plus importante en C#. Elle détermine comment les données sont stockées, copiées et comparées.

Value types (types valeur)

Les value types sont stockés directement sur la stack quand ce sont des variables locales. (Quand un value type est un champ d'une classe, il vit sur le heap avec l'objet parent.) Quand tu copies une variable, tu copies la valeur elle-même - les deux copies sont totalement indépendantes.

int a = 42;
int b = a;   // b reçoit une COPIE de la valeur
b = 100;

Console.WriteLine(a);  // 42  -  a n'a pas bougé
Console.WriteLine(b);  // 100

int a = 42;

int b = a;   // b reçoit une COPIE de la valeur

b = 100;

Console.WriteLine(a);  // 42  -  a n'a pas bougé

Console.WriteLine(b);  // 100

Les value types en C# : int, double, float, decimal, bool, char, byte, long, struct, enum, et tous les types numériques.

Reference types (types référence)

Les reference types sont stockés sur le heap, et la variable sur la stack ne contient qu'une référence (une adresse mémoire) vers l'objet. Quand tu copies une variable, tu copies la référence, pas l'objet - les deux variables pointent vers le même objet.

List<int> listeA = new List<int> { 1, 2, 3 };
List<int> listeB = listeA;  // listeB pointe vers LE MÊME objet
listeB.Add(4);

Console.WriteLine(listeA.Count);  // 4 ! listeA est aussi affectée

List<int> listeA = new List<int> { 1, 2, 3 };

List<int> listeB = listeA;  // listeB pointe vers LE MÊME objet

listeB.Add(4);

Console.WriteLine(listeA.Count);  // 4 ! listeA est aussi affectée

Les reference types en C# : class, string, object, interface, les tableaux (int[]), les delegates.

Le cas particulier de string

string est un type référence mais se comporte comme un type valeur. Pourquoi ? Parce que les strings sont immuables - chaque modification crée une nouvelle string au lieu de modifier l'existante.

string a = "Hello";
string b = a;
b = "World";

Console.WriteLine(a);  // "Hello"  -  a n'a pas changé

string a = "Hello";

string b = a;

b = "World";

Console.WriteLine(a);  // "Hello"  -  a n'a pas changé

b = "World" ne modifie pas la string "Hello". Ça crée une nouvelle string "World" sur le heap et fait pointer b vers elle. a pointe toujours vers "Hello".

# Pour aller plus loin

Tu comprends maintenant comment C# organise la mémoire. Deux articles approfondissent les conséquences pratiques :

• Passage de paramètres - par valeur, ref, out, in - comment tout ça se traduit en mémoire
• Le Garbage Collector - générations, IDisposable, using, les pièges courants

Les prochains articles de la série :

• Les interfaces, structs, records & enums
• C# vs .NET - ce qui est du langage et ce qui est du framework