enum (référence C#)enum (C# Reference)

Le mot clé enum est utilisé pour déclarer une énumération. Il s’agit d’un type distinct qui se compose d’un ensemble de constantes nommées, appelé liste d’énumérateurs.The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list.

Il est généralement préférable de définir une énumération directement dans un espace de noms pour que toutes les classes de l’espace de noms puissent y accéder avec la même facilité.Usually it is best to define an enum directly within a namespace so that all classes in the namespace can access it with equal convenience. Toutefois, une énumération peut également être imbriquée dans une classe ou un struct.However, an enum can also be nested within a class or struct.

Par défaut, le premier énumérateur a la valeur 0 et chaque énumérateur successif est augmenté de 1.By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1. Par exemple, dans l’énumération suivante, Sat est 0, Sun est 1, Mon est 2, et ainsi de suite.For example, in the following enumeration, Sat is 0, Sun is 1, Mon is 2, and so forth.

enum Day {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

Les énumérateurs peuvent utiliser des initialiseurs pour remplacer les valeurs par défaut, comme illustré dans l’exemple suivant.Enumerators can use initializers to override the default values, as shown in the following example.

enum Day {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

Dans cette énumération, le début de la séquence des éléments est forcé à 1 au lieu de 0.In this enumeration, the sequence of elements is forced to start from 1 instead of 0. Il est cependant recommandé d’inclure une constante qui a la valeur 0.However, including a constant that has the value of 0 is recommended. Pour plus d’informations, consultez Types énumération.For more information, see Enumeration Types.

Chaque type énumération a un type sous-jacent qui peut être tout type intégral sauf char.Every enumeration type has an underlying type, which can be any integral type except char. Le type sous-jacent par défaut des éléments de l’énumération est int. Pour déclarer une énumération d’un autre type intégral, comme byte, utilisez un signe deux-points après l’identificateur, suivi du type, comme illustré dans l’exemple suivant.The default underlying type of enumeration elements is int. To declare an enum of another integral type, such as byte, use a colon after the identifier followed by the type, as shown in the following example.

enum Day : byte {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

Les types approuvés d’une énumération sont byte, sbyte, short, ushort, int, uint, long ou ulong.The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.

Une variable de type énumération peut avoir n’importe quelle valeur de la plage du type sous-jacent ; les valeurs ne sont pas limitées aux constantes nommées.A variable of an enumeration type can be assigned any value in the range of the underlying type; the values are not limited to the named constants.

La valeur par défaut de enum E est la valeur produite par l’expression (E)0.The default value of an enum E is the value produced by the expression (E)0.

Note

Le nom d’un énumérateur ne peut pas contenir d’espaces.An enumerator cannot contain white space in its name.

Le type sous-jacent spécifie la quantité de stockage allouée pour chaque énumérateur.The underlying type specifies how much storage is allocated for each enumerator. Cependant, un cast explicite est nécessaire pour convertir du type enum en un type intégral.However, an explicit cast is necessary to convert from enum type to an integral type. Par exemple, l’instruction suivante affecte l’énumérateur Sun à une variable du type int en utilisant un cast pour convertir de enum en int.For example, the following statement assigns the enumerator Sun to a variable of the type int by using a cast to convert from enum to int.

int x = (int)Day.Sun;

Quand vous appliquez System.FlagsAttribute à une énumération qui contient des éléments qui peuvent être combinés avec une opération OR au niveau du bit, l’attribut affecte le comportement d’ enum quand elle est utilisée avec certains outils.When you apply System.FlagsAttribute to an enumeration that contains elements that can be combined with a bitwise OR operation, the attribute affects the behavior of the enum when it is used with some tools. Vous pouvez remarquer ces modifications quand vous utilisez des outils comme les méthodes de la classe Console et l’évaluateur d’expression.You can notice these changes when you use tools such as the Console class methods and the Expression Evaluator. (Voir le troisième exemple.)(See the third example.)

Programmation fiableRobust programming

Tout comme avec n’importe quelle constante, toutes les références aux valeurs individuelles d’une énumération sont converties en littéraux numériques au moment de la compilation.Just as with any constant, all references to the individual values of an enum are converted to numeric literals at compile time. Cette opération peut créer des problèmes potentiels de gestion de version, comme décrit dans Constantes.This can create potential versioning issues as described in Constants.

L’affectation de valeurs supplémentaires à de nouvelles versions d’énumérations ou la modification des valeurs des membres d’une énumération dans une nouvelle version peut entraîner des problèmes pour le code source dépendant.Assigning additional values to new versions of enums, or changing the values of the enum members in a new version, can cause problems for dependent source code. Les valeurs des énumérations sont souvent utilisées dans des instructions switch .Enum values often are used in switch statements. Si des éléments supplémentaires ont été ajoutées au type enum , la section par défaut de l’instruction switch peut être sélectionnée de façon inattendue.If additional elements have been added to the enum type, the default section of the switch statement can be selected unexpectedly.

Si d’autres développeurs utilisent votre code, vous devez fournir des instructions sur la manière dont leur code doit réagir si de nouveaux éléments sont ajoutés à des types enum .If other developers use your code, you should provide guidelines about how their code should react if new elements are added to any enum types.

ExempleExample

Dans l’exemple suivant, une énumération, Day, est déclarée.In the following example, an enumeration, Day, is declared. Deux énumérateurs sont explicitement convertis en entiers et affectés à des variables entières.Two enumerators are explicitly converted to integer and assigned to integer variables.

public class EnumTest
{
    enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

    static void Main()
    {
        int x = (int)Day.Sun;
        int y = (int)Day.Fri;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}
/* Output:
   Sun = 0
   Fri = 5
*/

ExempleExample

Dans l’exemple suivant, l’option de type de base est utilisée pour déclarer une enum dont les membres sont de type long.In the following example, the base-type option is used to declare an enum whose members are of type long. Notez que même si le type sous-jacent de l’énumération est long, les membres de l’énumération doivent toujours être explicitement convertis en type long en utilisant un cast.Notice that even though the underlying type of the enumeration is long, the enumeration members still must be explicitly converted to type long by using a cast.

public class EnumTest2
{
    enum Range : long { Max = 2147483648L, Min = 255L };
    static void Main()
    {
        long x = (long)Range.Max;
        long y = (long)Range.Min;
        Console.WriteLine("Max = {0}", x);
        Console.WriteLine("Min = {0}", y);
    }
}
/* Output:
   Max = 2147483648
   Min = 255
*/

ExempleExample

L’exemple de code suivant montre l’utilisation et l’effet de l’attribut System.FlagsAttribute sur une déclaration enum .The following code example illustrates the use and effect of the System.FlagsAttribute attribute on an enum declaration.

// Add the attribute Flags or FlagsAttribute.
[Flags]
public enum CarOptions
{
    // The flag for SunRoof is 0001.
    SunRoof = 0x01,
    // The flag for Spoiler is 0010.
    Spoiler = 0x02,
    // The flag for FogLights is 0100.
    FogLights = 0x04,
    // The flag for TintedWindows is 1000.
    TintedWindows = 0x08,
}

class FlagTest
{
    static void Main()
    {
        // The bitwise OR of 0001 and 0100 is 0101.
        CarOptions options = CarOptions.SunRoof | CarOptions.FogLights;

        // Because the Flags attribute is specified, Console.WriteLine displays
        // the name of each enum element that corresponds to a flag that has
        // the value 1 in variable options.
        Console.WriteLine(options);
        // The integer value of 0101 is 5.
        Console.WriteLine((int)options);
    }
}
/* Output:
   SunRoof, FogLights
   5
*/

CommentairesComments

Si vous supprimez Flags, l’exemple affiche les valeurs suivantes :If you remove Flags, the example displays the following values:

5

5

spécification du langage C#C# language specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also