Parcourir toutes les valeurs d’un enum est un besoin courant en C#. Vous pourriez avoir besoin de remplir une liste déroulante, valider une entrée ou effectuer une action pour chaque membre de l’enum. Ce guide couvre toutes les approches pour parcourir les enums, y compris les méthodes d’aide génériques et la gestion des enums de flags.

Définir un enum d’exemple

Tous les exemples de cet article utilisent l’enum suivant :

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Méthode 1 : Enum.GetValues avec foreach

L’approche la plus courante utilise Enum.GetValues, qui retourne un Array de toutes les valeurs définies dans l’enum :

foreach (Season season in Enum.GetValues(typeof(Season)))
{
    Console.WriteLine(season);
}

Sortie :

Spring
Summer
Autumn
Winter

La conversion du Array retourné en Season est implicite lorsque vous déclarez la variable de boucle avec le type de l’enum.

Méthode 2 : Générique Enum.GetValues (.NET 5+)

À partir de .NET 5, une surcharge générique est disponible qui retourne un tableau fortement typé, éliminant le besoin de typeof :

foreach (Season season in Enum.GetValues<Season>())
{
    Console.WriteLine(season);
}

C’est l’approche la plus propre pour les applications .NET modernes.

Méthode 3 : Enum.GetNames

Si vous n’avez besoin que des noms sous forme de chaînes des membres de l’enum, utilisez Enum.GetNames :

foreach (string name in Enum.GetNames(typeof(Season)))
{
    Console.WriteLine(name);
}

Ou avec la surcharge générique (.NET 5+) :

foreach (string name in Enum.GetNames<Season>())
{
    Console.WriteLine(name);
}

Cela retourne les mêmes chaînes que vous obtiendriez en appelant .ToString() sur chaque valeur de l’enum, mais sans la surcharge du boxing et unboxing.

Méthode 4 : LINQ avec les valeurs d’Enum

Vous pouvez utiliser LINQ pour filtrer, trier ou transformer les valeurs d’enum :

var warmSeasons = Enum.GetValues<Season>()
    .Where(s => s == Season.Spring || s == Season.Summer)
    .ToList();

foreach (var season in warmSeasons)
{
    Console.WriteLine(season);
}

Créer un dictionnaire à partir d’un Enum

Un motif courant consiste à construire un dictionnaire qui associe les valeurs entières aux noms :

var seasonDict = Enum.GetValues<Season>()
    .ToDictionary(s => (int)s, s => s.ToString());

// {0: "Spring", 1: "Summer", 2: "Autumn", 3: "Winter"}

Méthode 5 : Conversion en tableau pour l’accès par index

Si vous avez besoin d’accéder aux valeurs de l’enum par index :

Season[] seasons = (Season[])Enum.GetValues(typeof(Season));
Season third = seasons[2]; // Autumn
int count = seasons.Length; // 4

Ou avec la version générique :

Season[] seasons = Enum.GetValues<Season>();

Remplir une liste déroulante à partir d’un Enum

L’un des usages les plus courants dans le monde réel est le remplissage d’un contrôle d’interface utilisateur :

// Windows Forms ComboBox
comboBox.DataSource = Enum.GetValues<Season>();

// ASP.NET MVC SelectList
var items = Enum.GetValues<Season>()
    .Select(s => new SelectListItem
    {
        Value = ((int)s).ToString(),
        Text = s.ToString()
    })
    .ToList();

Analyser des chaînes en valeurs d’Enum

Pour convertir une chaîne en valeur d’enum, utilisez Enum.Parse ou Enum.TryParse :

// Throws ArgumentException if invalid
Season parsed = (Season)Enum.Parse(typeof(Season), "Summer");

// Safe parsing (returns false if invalid)
if (Enum.TryParse<Season>("Summer", out Season result))
{
    Console.WriteLine(result); // Summer
}

// Case-insensitive parsing
Enum.TryParse<Season>("summer", ignoreCase: true, out Season result2);

Conversion entre Enum et entier

// Enum to int
int value = (int)Season.Autumn; // 2

// Int to enum
Season season = (Season)2; // Autumn

// Check if value is defined
bool isDefined = Enum.IsDefined(typeof(Season), 2); // true
bool isUndefined = Enum.IsDefined(typeof(Season), 99); // false

Travailler avec les Enums de Flags

Les enums de flags utilisent l’attribut [Flags] et des valeurs binaires, permettant les combinaisons :

[Flags]
public enum FilePermissions
{
    None    = 0,
    Read    = 1,
    Write   = 2,
    Execute = 4,
    All     = Read | Write | Execute
}

Itérer les flags individuels

Enum.GetValues retourne toutes les valeurs définies, y compris les combinaisons comme All. Pour itérer uniquement les flags individuels définis sur une valeur donnée :

FilePermissions perms = FilePermissions.Read | FilePermissions.Write;

foreach (FilePermissions flag in Enum.GetValues<FilePermissions>())
{
    if (flag != FilePermissions.None && perms.HasFlag(flag))
    {
        Console.WriteLine(flag);
    }
}
// Output: Read, Write

Vérifier les flags individuels

FilePermissions perms = FilePermissions.Read | FilePermissions.Execute;

bool canRead = perms.HasFlag(FilePermissions.Read);       // true
bool canWrite = perms.HasFlag(FilePermissions.Write);     // false
bool canExecute = perms.HasFlag(FilePermissions.Execute); // true

Méthodes d’aide génériques

Vous pouvez créer des méthodes d’aide réutilisables pour les opérations sur les enums :

public static class EnumHelper
{
    /// <summary>
    /// Gets all values of an enum as a typed list.
    /// </summary>
    public static List<T> GetAllValues<T>() where T : struct, Enum
    {
        return Enum.GetValues<T>().ToList();
    }

    /// <summary>
    /// Gets a dictionary mapping enum names to values.
    /// </summary>
    public static Dictionary<string, T> GetNameValuePairs<T>() where T : struct, Enum
    {
        return Enum.GetValues<T>()
            .ToDictionary(e => e.ToString(), e => e);
    }

    /// <summary>
    /// Safely parses a string to an enum, returning a default value if parsing fails.
    /// </summary>
    public static T ParseOrDefault<T>(string value, T defaultValue = default)
        where T : struct, Enum
    {
        return Enum.TryParse<T>(value, ignoreCase: true, out T result)
            ? result
            : defaultValue;
    }
}

Utilisation :

List<Season> allSeasons = EnumHelper.GetAllValues<Season>();
Season parsed = EnumHelper.ParseOrDefault<Season>("summer", Season.Spring);

Référence rapide

Tâche	Méthode
Parcourir toutes les valeurs	`Enum.GetValues<T>()`
Parcourir tous les noms	`Enum.GetNames<T>()`
Analyser une chaîne en enum	`Enum.TryParse<T>(string, out T)`
Enum vers int	`(int)enumValue`
Int vers enum	`(T)intValue`
Vérifier si une valeur est définie	`Enum.IsDefined(typeof(T), value)`
Vérifier si un flag est défini	`value.HasFlag(flag)`

Résumé

La manière la plus simple de parcourir un enum en C# est foreach (var value in Enum.GetValues<T>()) sur .NET 5 et ultérieur, ou Enum.GetValues(typeof(T)) sur les frameworks plus anciens. Utilisez Enum.GetNames lorsque vous n’avez besoin que des noms sous forme de chaînes, et utilisez l’attribut [Flags] avec HasFlag pour les combinaisons binaires d’enums. Pour du code réutilisable, créez des méthodes d’aide génériques avec la contrainte where T : struct, Enum.