Le boxing est la conversion d'un type valeur (comme int) en un type référence (object) — l'encapsulation dans un objet sur le tas. L'unboxing est l'inverse (l'extraction de la valeur). Les deux ont un coût de performance (allocation sur le tas, copie), et les comprendre vous aide à éviter les surcharges inutiles.
int number = 42; // a value type (on the stack)
object boxed = number; // BOXING — wraps 42 in an object ON THE HEAP (allocation + copy)
int unboxed = (int)boxed; // UNBOXING — extracts the value back (copy, requires a cast)
Le boxing alloue un nouvel objet sur le tas et copie la valeur dedans ; l'unboxing la copie à nouveau. Chaque opération de boxing est une allocation sur le tas — peu coûteuse une fois, mais onéreuse dans les chemins critiques ou les boucles.
// ❌ using a value type where an `object` is expected → implicit boxing
object obj = 42; // boxing
ArrayList list = new(); list.Add(42); // boxes (non-generic — stores object)
string s = string.Format("{0}", 42); // boxing for the object[] params
// these can box repeatedly in loops → significant GC pressure
Le boxing se produit souvent implicitement — chaque fois qu'un type valeur est utilisé là où object (ou une interface non générique) est attendu. Dans les boucles ou les chemins critiques, le boxing répété crée de nombreux objets sur le tas à courte durée de vie, nuisant à la performance.
// ❌ non-generic collection — boxes every value type added
ArrayList list = new();
list.Add(42); // boxes
// ✅ generic collection — NO boxing, type-safe
List<int> list = new();
list.Add(42); // no boxing — stored as int directly
La solution principale est d'utiliser les génériques (List<int> au lieu de ArrayList) — les génériques stockent les types valeurs directement sans boxing. C'est l'un des principaux avantages de performance des génériques par rapport aux anciennes collections non génériques.
Comprendre le boxing et l'unboxing est important pour écrire du C# performant et pour apprécier pourquoi les génériques ont de l'importance.
Le boxing — la conversion d'un type valeur en un type référence (object) — entraîne une allocation sur le tas et une copie, et l'unboxing copie la valeur à nouveau, donc les deux ont un coût de performance.
Bien qu'une seule opération de boxing soit peu coûteuse, le problème est que le boxing se produit souvent implicitement (chaque fois qu'un type valeur est utilisé là où un object est attendu) et peut se produire répétées fois dans les boucles ou les chemins critiques, créant de nombreux objets sur le tas à courte durée de vie qui augmentent la pression sur le GC et dégradent les performances — un problème subtil et facile à manquer.
Le point pratique clé est que les génériques évitent le boxing : l'utilisation de List<int> au lieu de l'ancien ArrayList non générique stocke les types valeurs directement sans boxing, ce qui est l'un des principaux avantages de performance des génériques par rapport aux collections non génériques hérités (et une raison clé d'utiliser toujours les collections génériques).
Comprendre ce qu'est le boxing/unboxing, quand cela se produit (souvent invisiblement), leur coût de performance (allocation, pression du GC, surtout dans les boucles), et comment les génériques les préviennent est une connaissance importante pour écrire du C# efficace et pour comprendre pourquoi les collections génériques sont préférées.
Puisque le boxing est une source courante et subtile de surcharge de performance, et puisque l'éviter (via les génériques) est une pratique de performance fondamentale, comprendre le boxing/unboxing est une connaissance précieuse et pratiquement pertinente qui distingue les développeurs C# conscients de la performance et est un sujet fréquent d'entretien reflétant la compréhension du modèle type valeur/référence et des avantages des génériques.