Ce sont trois types distincts en C# : enum (un ensemble nommé de valeurs constantes), struct (un type valeur pour les petites données), et class (un type référence pour les objets). Choisir correctement dépend des données et du comportement que vous modélisez.
Status { Active, Inactive, Pending }
Status s = Status.Active;
(s == Status.Active) { }
Permissions { Read = , Write = , Execute = }
Une enum définit un ensemble fixe de valeurs nommées — des constantes type-safe pour des choses comme les états, les rôles ou les options (remplaçant les nombres/chaînes magiques). C'est un type valeur basé sur un entier.
public struct Point // VALUE type — copied by value, no heap allocation
{
public int X { get; }
public int Y { get; }
public Point(int x, int y) { X = x; Y = y; }
}
Point p1 = new(1, 2);
Point p2 = p1; // COPIES the whole struct (independent)
Une struct est un type valeur — stockée inline (souvent sur la pile), copiée par valeur, pas d'allocation sur le heap. Meilleure pour les valeurs petites, immuables, de type données (coordonnées, montant d'argent, une date) où la sémantique de valeur et l'absence d'allocation sur le heap aident la performance.
public class User // REFERENCE type — on the heap, copied by reference
{
public string Name { get; set; }
public void DoWork() { } // rich behavior
}
User u1 = new() { Name = "Ann" };
User u2 = u1; // both reference the SAME object
Une class est un type référence — sur le heap, copiée par référence (partagée), supporte l'héritage et un riche comportement. Le choix par défaut pour la plupart des objets avec identité, comportement et état mutable.
enum → a fixed set of named constants (states, roles, options)
struct → small, immutable data values; value semantics; avoid heap allocation
(keep small — large structs are costly to copy)
class → most objects: identity, behavior, inheritance, mutable/larger state (the default)
Choisir le bon type — enum, struct ou class — est une décision de conception C# fondamentale affectant la justesse, la sémantique et la performance, donc comprendre les différences est important. Les enums fournissent des constantes nommées type-safe (pour les états, rôles, options), bien mieux que les nombres magiques ou chaînes sujets à erreurs — un outil de modélisation courant et précieux.
La distinction struct vs class est particulièrement significative car elle détermine la sémantique de valeur vs référence : les structs sont des types valeur (copiés par valeur, stockés inline, pas d'allocation sur le heap) adaptés aux petites valeurs immuables où la sémantique de valeur et l'allocation réduite aident la performance, tandis que les classes sont des types référence (partagés par référence, alloués sur le heap, supportant l'héritage et un riche comportement) — le défaut pour la plupart des objets avec identité et comportement.
Choisir mal a des conséquences réelles : une struct grande est coûteuse à copier, et utiliser une struct où la sémantique de référence est attendue (ou vice versa) provoque des bugs subtils.
Comprendre quand utiliser chacune — enum pour les ensembles de constantes fixes, struct pour les petites valeurs de type données (gardées petites), class pour la plupart des objets (le défaut) — et les implications valeur-vs-référence est une connaissance importante pour modéliser les données correctement et efficacement en C#.
Puisque ce choix apparaît chaque fois que vous définissez un type, et puisque la distinction valeur/référence sous-tend tant de comportement C#, connaître les différences et l'utilisation appropriée des enums, structs et classes est une connaissance fondamentale, fréquemment pertinente et un sujet d'interview courant reflétant la compréhension du système de types de C#.