Partager via

Types d’énumération (référence C#)

Un type d’énumération (ou type enum) est un type valeur défini par un ensemble de constantes nommées du type numérique intégral sous-jacent. Pour définir un type d’énumération, utilisez le enum mot clé et spécifiez les noms des membres d’énumération :

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Par défaut, les valeurs constantes associées des membres d’énumération sont de type int; elles commencent par zéro et augmentent d’une suite à l’ordre de texte de définition. Vous pouvez spécifier explicitement tout autre type numérique intégral comme type sous-jacent d’un type d’énumération. Vous pouvez également spécifier explicitement les valeurs de constante associées, comme l’illustre l’exemple suivant :

enum ErrorCode : ushort
{
    None = 0,
    Unknown = 1,
    ConnectionLost = 100,
    OutlierReading = 200
}

Vous ne pouvez pas définir une méthode à l’intérieur de la définition d’un type d’énumération. Pour ajouter des fonctionnalités à un type d’énumération, créez une méthode d’extension.

La valeur par défaut d’un type E d’énumération est la valeur produite par l’expression (E)0, même si zéro n’a pas le membre d’énumération correspondant.

Vous utilisez un type d’énumération pour représenter un choix à partir d’un ensemble de valeurs mutuellement exclusives ou d’une combinaison de choix. Pour représenter une combinaison de choix, définissez un type d’énumération en tant qu’indicateurs de bits.

Types d’énumération en tant qu’indicateurs de bits

Si vous souhaitez qu’un type d’énumération représente une combinaison de choix, définissez des membres d’énumération pour ces choix de sorte qu’un choix individuel soit un champ de bits. Autrement dit, les valeurs associées de ces membres enum doivent être les puissances de deux. Ensuite, vous pouvez utiliser les opérateurs logiques au niveau du bit | ou & pour combiner ou intercepter des combinaisons de choix, respectivement. Pour indiquer qu’un type d’énumération déclare des champs de bits, appliquez l’attribut Indicateurs à celui-ci. Comme l’illustre l’exemple suivant, vous pouvez également inclure certaines combinaisons classiques dans la définition d’un type d’énumération.

[Flags]
public enum Days
{
    None      = 0b_0000_0000,  // 0
    Monday    = 0b_0000_0001,  // 1
    Tuesday   = 0b_0000_0010,  // 2
    Wednesday = 0b_0000_0100,  // 4
    Thursday  = 0b_0000_1000,  // 8
    Friday    = 0b_0001_0000,  // 16
    Saturday  = 0b_0010_0000,  // 32
    Sunday    = 0b_0100_0000,  // 64
    Weekend   = Saturday | Sunday
}

public class FlagsEnumExample
{
    public static void Main()
    {
        Days meetingDays = Days.Monday | Days.Wednesday | Days.Friday;
        Console.WriteLine(meetingDays);
        // Output:
        // Monday, Wednesday, Friday

        Days workingFromHomeDays = Days.Thursday | Days.Friday;
        Console.WriteLine($"Join a meeting by phone on {meetingDays & workingFromHomeDays}");
        // Output:
        // Join a meeting by phone on Friday

        bool isMeetingOnTuesday = (meetingDays & Days.Tuesday) == Days.Tuesday;
        Console.WriteLine($"Is there a meeting on Tuesday: {isMeetingOnTuesday}");
        // Output:
        // Is there a meeting on Tuesday: False

        var a = (Days)37;
        Console.WriteLine(a);
        // Output:
        // Monday, Wednesday, Saturday
    }
}

Pour plus d’informations et d’exemples, consultez la page de référence de l’API System.FlagsAttribute et les membres non exclusifs et la section attribut Indicateurs de la page de référence de l’API System.Enum .

Type System.Enum et contrainte d’énumération

Le System.Enum type est la classe de base abstraite de tous les types d’énumération. Il fournit un certain nombre de méthodes pour obtenir des informations sur un type d’énumération et ses valeurs. Pour plus d’informations et d’exemples, consultez la page de référence de l’API System.Enum .

Vous pouvez utiliser System.Enum dans une contrainte de classe de base (appelée contrainte d’énumération) pour spécifier qu’un paramètre de type est un type d’énumération. Tout type d’énumération satisfait également la struct contrainte, utilisée pour spécifier qu’un paramètre de type est un type valeur non nullable.

Transformations

Pour tout type d’énumération, il existe des conversions explicites entre le type d’énumération et son type intégral sous-jacent. Si vous convertissez une valeur d’énumération vers son type sous-jacent, le résultat est la valeur intégrale associée d’un membre d’énumération.

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

public class EnumConversionExample
{
    public static void Main()
    {
        Season a = Season.Autumn;
        Console.WriteLine($"Integral value of {a} is {(int)a}");  // output: Integral value of Autumn is 2

        var b = (Season)1;
        Console.WriteLine(b);  // output: Summer

        var c = (Season)4;
        Console.WriteLine(c);  // output: 4
    }
}

Utilisez la Enum.IsDefined méthode pour déterminer si un type d’énumération contient un membre d’énumération avec la valeur associée.

Pour tout type d’énumération, il existe respectivement, des conversions de boxing et d’unboxing vers et à partir du typeSystem.Enum.

Spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

Voir aussi