Quelle est la différence entre une enum, une struct et une class ?

Question

IT Interview Practice · Accepted Answer

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.

## enum — un ensemble nommé de constantes

```csharp
public enum Status { Active, Inactive, Pending }   // named constants (Active=0, ...)

Status s = Status.Active;
if (s == Status.Active) { }                         // type-safe constants

public enum Permissions { Read = 1, Write = 2, Execute = 4 }   // [Flags] for bit flags
```

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.

## struct — un type valeur pour les petites données

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

## class — un type référence pour les objets

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

## Quand utiliser quoi

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

## Pourquoi c'est important

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

enum — un ensemble nommé de constantes

struct — un type valeur pour les petites données

class — un type référence pour les objets

Quand utiliser quoi

Pourquoi c'est important

Questions connexes