Partager via

Énumérations C#

Conseil / Astuce

Vous débutez avec le développement de logiciels ? Commencez par commencer par les didacticiels De prise en main . Vous rencontrerez des enums lorsque vous devez représenter un ensemble fixe de choix dans votre code.

Maîtrisez-vous une autre langue ? Les énumérations C# fonctionnent de la même façon que les énumérations en Java ou C++, avec une prise en charge supplémentaire des indicateurs de bits et de la correspondance de modèles. Parcourez les sections indicateurs et expression switch pour les modèles spécifiques à C#.

Un type d’énumération (ou énumération) définit un ensemble de constantes nommées sauvegardées par une valeur entière. Utilisez des énumérations lorsqu’une valeur doit être l’un des ensembles fixes d’options ( jours de la semaine, codes d’état HTTP, niveaux de journal ou directions). Les énumérations rendent votre code plus lisible et moins sujette aux erreurs que les constantes entières brutes, car le compilateur applique les valeurs nommées.

Déclarer une énumération

Définissez une énumération avec le enum mot clé suivi du nom de type et de ses membres :

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Par défaut, le type sous-jacent est int, et les valeurs commencent par 0 incrémenter par un. Season.Spring est 0, Season.Summer est 1, et ainsi de suite.

Spécifier un type sous-jacent et des valeurs explicites

Vous pouvez choisir un type intégral différent et affecter des valeurs explicites pour contrôler la représentation numérique :

enum HttpStatus : ushort
{
    OK = 200,
    NotFound = 404,
    InternalServerError = 500
}

Utilisez des valeurs explicites lorsque les nombres ont une signification externe, comme les codes d’état HTTP ou les identificateurs de protocole. Le type sous-jacent peut être n’importe quel type intégral , sauf char. Utilisez byte, shortushortint, uint, long, ou .ulong

Utiliser des énumérations dans les expressions switch

Les énumérations fonctionnent naturellement avec switch des expressions et des critères correspondants. Le compilateur vous avertit si vous ne gérez pas tous les membres, ce qui permet d’éviter les bogues lorsque vous ajoutez une nouvelle valeur ultérieurement :

static string DescribeSeason(Season season) => season switch
{
    Season.Spring => "Flowers bloom and temperatures rise.",
    Season.Summer => "Long days and warm weather.",
    Season.Autumn => "Leaves change color and fall.",
    Season.Winter => "Short days and cold temperatures.",
    _ => throw new ArgumentOutOfRangeException(nameof(season))
};

var today = Season.Autumn;
Console.WriteLine(DescribeSeason(today));

Le modèle d’abandon (_) gère n’importe quelle valeur non répertoriée explicitement. La mise en correspondance des modèles est une fonctionnalité C# qui teste une valeur par rapport à une forme ou une condition. Dans cet exemple, chacun case vérifie si l’énumération correspond à un membre spécifique. Les expressions switch sont l'une des formes de correspondance de motifs. Pour plus d’informations sur la mise en correspondance des modèles, consultez Mise en correspondance des modèles.

Indicateurs de bits

Lorsqu’une énumération représente une combinaison de choix plutôt qu’un choix unique, définissez chaque membre comme une puissance de deux et appliquez les FlagsAttributeéléments suivants :

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

Combinez des valeurs à l’aide de l’opérateur | et testez les indicateurs individuels à l’aide HasFlagde :

var permissions = FileAccess.Read | FileAccess.Write;

Console.WriteLine(permissions);                          // ReadWrite
Console.WriteLine(permissions.HasFlag(FileAccess.Read)); // True
Console.WriteLine(permissions.HasFlag(FileAccess.Execute)); // False

L’attribut [Flags] affecte ToString()également . Il affiche des valeurs combinées sous forme de noms séparés par des virgules (comme Read, Write) au lieu d’un nombre brut. Pour plus d’informations, consultez System.FlagsAttribute.

Convertir entre les énumérations et les entiers

Les casts explicites permettent de convertir entre une énumération et son type entier sous-jacent.

var status = HttpStatus.NotFound;
ushort code = (ushort)status;
Console.WriteLine($"Status: {status} ({code})"); // Status: NotFound (404)

var fromCode = (HttpStatus)200;
Console.WriteLine(fromCode); // OK

N’oubliez pas que la conversion d’un entier en énumération ne valide pas si la valeur correspond à un membre défini. Permet Enum.IsDefined de vérifier la validité lorsque vous acceptez une entrée numérique à partir de sources externes.

Analyser des chaînes et itérer des valeurs

La Enum classe de base fournit des méthodes d’analyse de chaînes et d’itération sur toutes les valeurs définies :

// Parse a string to an enum value:
var parsed = Enum.Parse<Season>("Winter");
Console.WriteLine(parsed); // Winter

// Try to parse safely. It returns false only when the input can't be parsed. Call Enum.IsDefined to validate named members:
if (Enum.TryParse<Season>("Monsoon", out var unknown))
{
    Console.WriteLine(unknown);
}
else
{
    Console.WriteLine("'Monsoon' is not a valid Season"); // 'Monsoon' is not a valid Season
}

// Iterate over all values in an enum:
foreach (var season in Enum.GetValues<Season>())
{
    Console.WriteLine($"{season} = {(int)season}");
}
// Spring = 0
// Summer = 1
// Autumn = 2
// Winter = 3

Utilisez Enum.TryParse<TEnum>(String, Boolean, TEnum) plutôt que Enum.Parse<TEnum>(String) lorsque l’entrée pourrait être invalide. Elle retourne false au lieu de lever une exception.

Voir également

  • Last updated on