Les énumérations (enum) en C# : des constantes nommées pratiques

1. Introduction

En programmation, on doit souvent manipuler des listes de variantes connues à l'avance et limitées. Par exemple : les jours de la semaine, les couleurs d'un feu de signalisation, les niveaux de difficulté d'un jeu, les statuts d'une commande. Chacune de ces variantes est généralement représentée par une valeur fixe. Et c'est là qu'on arrive à notre sujet du jour — les énumérations (enum).

Une énumération — c'est un type de données spécial qui permet de déclarer un ensemble de constantes nommées.
enum — c'est comme une boîte avec des étiquettes rangées dans des cases, où chaque étiquette est un nom unique associé à un nombre.

• Ton code devient lisible et auto-documenté ;
• Au lieu de mystérieux « nombres magiques » comme 0, 1, 2 tu as des noms explicites : DayOfWeek.Monday ou TrafficLight.Red ;
• Le compilateur va râler si tu essaies d'assigner une valeur incorrecte ;
• Derrière chaque élément se cache… un simple nombre entier ! (Mais on va y revenir.)

2. Syntaxe de déclaration d'une énumération

On va créer notre première énumération — types de météo pour notre future appli. Voilà à quoi ça ressemble :

// Enumération des conditions météo
public enum WeatherCondition
{
    Sunny,       // 0
    Cloudy,      // 1
    Rainy,       // 2
    Stormy,      // 3
    Snowy        // 4
}

• Le mot-clé enum définit un nouveau type.
• Dans les accolades — les noms des variantes. Par défaut, chaque variante reçoit un nombre entier à partir de zéro (Sunny == 0, Cloudy == 1 etc.).
• On peut aussi définir les valeurs explicitement :

public enum WeatherCondition
{
    Sunny = 1,
    Cloudy = 2,
    Rainy = 4,
    Stormy = 8,
    Snowy = 16
}

C'est pratique si les valeurs doivent correspondre à des standards ou protocoles externes.

3. Utilisation des énumérations

Imaginons qu'on a codé une appli — un petit programme console qui réagit à la météo.

// Classe de l'application
class Program
{
    static void Main()
    {
        // On utilise notre énumération pour stocker l'état de la météo
        WeatherCondition todayWeather = WeatherCondition.Sunny;

        // On affiche à l'écran
        Console.WriteLine($"Aujourd'hui la météo : {todayWeather} ({(int)todayWeather})");

        // Et maintenant on simule un changement de météo
        todayWeather = WeatherCondition.Rainy;
        Console.WriteLine($"Oups ! La météo a changé : {todayWeather} ({(int)todayWeather})");
    }
}

Qu'est-ce qui va se passer ?

Aujourd'hui la météo : Sunny (0)
Oups ! La météo a changé : Rainy (2)

• todayWeather — ce n'est pas une string, ni un nombre, mais un élément d'énumération.
• Le cast en (int) permet de voir le « code numérique » de la valeur.

Au fait, les énumérations marchent super bien avec les conditions :

if (todayWeather == WeatherCondition.Rainy)
    Console.WriteLine("Prends un parapluie !");

4. Scénarios pratiques d'utilisation des enum

Où on croise les énumérations ?

• Dans les applis business : statuts de commandes (New, Processing, Shipped, Cancelled).
• Dans les systèmes de gestion d'utilisateurs : niveaux d'accès (User, Moderator, Admin).
• Dans les jeux : états du personnage (Idle, Moving, Jumping, Falling).
• Dans les GUI : boutons, messages, couleurs d'icônes.

Et si tu creuses dans .NET — tu les trouves dans quasi une classe sur deux de la bibliothèque standard ! Par exemple, pour les opérations sur les fichiers, il y a des énumérations pour indiquer le mode d'ouverture (lecture, écriture, création).

5. Valeurs explicites et plage de valeurs

Parfois, tu veux convertir un ensemble de valeurs int utilisées dans le code en enum. C'est super simple :

public enum CompassDirection
{
    North = 10,
    East = 20,
    South = 30,
    West = 40
}

Maintenant CompassDirection.North = 10, East = 20, etc. Si un élément n'a pas de valeur explicite, il prend automatiquement la valeur précédente +1.

Type de stockage

Par défaut, enum est stocké comme un int (entier 4 octets). Mais tu peux préciser ton type de base si tu veux économiser de la mémoire :

public enum TinyEnum : byte
{
    First,  // 0
    Second, // 1
    Third   // 2
}

Maintenant chaque valeur d'énumération — c'est juste un octet !

Liste complète des types possibles : byte, sbyte, short, ushort, int, uint, long, ulong.

6. Conversion entre enum et nombres/chaînes

Conversion enum ↔ int :

Pour convertir un enum en int et inversement, tu peux juste utiliser un cast :

WeatherCondition current = WeatherCondition.Cloudy;
int number = (int)current; // On obtient 1

WeatherCondition fromNumber = (WeatherCondition)2; // On obtient Rainy

Conversion enum ↔ string :

Pour convertir un enum en string, il suffit d'appeler la méthode ToString().

// On convertit enum en string
string name = WeatherCondition.Stormy.ToString(); // "Stormy"

// On convertit une string en enum avec Enum.Parse
WeatherCondition parsed = (WeatherCondition)Enum.Parse(typeof(WeatherCondition), "Stormy");

// On peut aussi utiliser Enum.TryParse
WeatherCondition parsedOk;
if (Enum.TryParse("Snowy", out parsedOk))
{
    Console.WriteLine(parsedOk); // Snowy
}

Erreur typique :
Si tu castes un nombre en enum qui n'a pas de membre défini, le compilateur ne dira rien, mais tu obtiens un état "virtuel".
Par exemple :

WeatherCondition weird = (WeatherCondition)999;
Console.WriteLine(weird); // 999 (ça ne deviendra pas "Unknown" !)

Donc, le dev doit faire gaffe avec ce genre de conversion.

7. switch et enum sont faits l'un pour l'autre

Les énumérations (enum) vont super bien avec l'opérateur switch. C'est une façon pratique et claire de “réagir” à différentes valeurs d'énumération — sans une ribambelle de “if-else”.

Exemple : réaction à la météo

public enum WeatherCondition
{
    Sunny,
    Cloudy,
    Rainy,
    Stormy,
    Snowy
}

WeatherCondition today = WeatherCondition.Rainy;

switch (today)
{
    case WeatherCondition.Sunny:
        Console.WriteLine("Ensoleillé ! Tu peux sortir te balader.");
        break;
    case WeatherCondition.Cloudy:
        Console.WriteLine("Nuageux. Prends un pull.");
        break;
    case WeatherCondition.Rainy:
        Console.WriteLine("Il pleut. N'oublie pas ton parapluie !");
        break;
    case WeatherCondition.Stormy:
        Console.WriteLine("Tempête ! Mieux vaut rester à la maison.");
        break;
    case WeatherCondition.Snowy:
        Console.WriteLine("Il neige — mets un bonnet !");
        break;
    default:
        Console.WriteLine("Météo inconnue...");
        break;
}

• Chaque cas (case) correspond à une valeur d'énumération.
• Si la valeur ne correspond à aucune des variantes connues, c'est default qui s'exécute (pratique si jamais une valeur inattendue arrive dans la variable).

Pourquoi le combo enum + switch est cool ?

• Code lisible : toutes les variantes possibles sont visibles dans la liste case.
• Facile à étendre : tu ajoutes un nouveau type de météo — tu ajoutes juste un case de plus.
• Sécurité : le compilateur te prévient si tu oublies de traiter tous les cas (depuis C# 8.0 tu peux même activer la vérification d'exhaustivité).

Exemple : enum avec logique pour un jeu

public enum GameState
{
    Start,
    Playing,
    Paused,
    GameOver
}

void PrintState(GameState state)
{
    switch (state)
    {
        case GameState.Start:
            Console.WriteLine("Bienvenue dans le jeu !");
            break;
        case GameState.Playing:
            Console.WriteLine("La partie est en cours. Bonne chance !");
            break;
        case GameState.Paused:
            Console.WriteLine("Pause. Tu peux souffler un peu.");
            break;
        case GameState.GameOver:
            Console.WriteLine("Partie terminée. Essaie encore !");
            break;
        default:
            Console.WriteLine("État du jeu inconnu.");
            break;
    }
}

Astuces :

• Si tu as beaucoup d'actions similaires pour plusieurs variantes, tu peux les regrouper :

switch (today)
{
    case WeatherCondition.Rainy:
    case WeatherCondition.Stormy:
        Console.WriteLine("N'oublie pas le parapluie et des fringues chaudes !");
        break;
}

• N'oublie pas le default, pour gérer les valeurs inattendues (genre si quelqu'un caste un nombre en enum direct).
• Avec switch c'est pratique de faire des “machines à états”, des menus et tous les systèmes avec un ensemble de variantes fixes.

8. Énumérations et méthodes/services principaux de .NET

.NET fournit plein de méthodes utiles pour les énumérations :

• Enum.GetNames(typeof(WeatherCondition)) — obtenir tous les noms.
• Enum.GetValues(typeof(WeatherCondition)) — toutes les valeurs.
• Enum.IsDefined(typeof(WeatherCondition), "Rainy") — savoir si l'énumération a ce membre.
• Documentation : System.Enum

Exemple d'affichage de toutes les variantes météo :

foreach (var name in Enum.GetNames(typeof(WeatherCondition)))
{
    Console.WriteLine(name);
}

9. Erreurs fréquentes et « pièges »

• Utiliser des "nombres magiques" au lieu des énumérations, ce qui rend le code illisible.
• Ne pas gérer les valeurs qui ne sont pas définies dans l'énumération (voir le point sur le cast de nombre).
• Donner aux éléments d'énumération des noms sans sens (Value1, Value2... — et plus personne ne sait ce que ça veut dire).
• Violer le principe de responsabilité unique — utiliser une seule énumération pour des choses différentes.

La meilleure solution : utilise toujours des énumérations quand tu as un ensemble fini de variantes, et donne aux éléments des noms explicites et auto-documentés.