enum (référence C#)
Le mot clé enum est utilisé pour déclarer une énumération, c'est-à-dire un type distinct constitué d'un ensemble de constantes nommées que l'on appelle « liste d'énumérateurs ».
Généralement, il vaut mieux définir directement un enum dans un espace de noms afin que toutes les classes de cet espace puissent y accéder aussi aisément. Toutefois, un enum peut également être imbriqué dans une classe ou un struct.
Par défaut, le premier énumérateur a la valeur 0, et chaque énumérateur suivant a la valeur n+1. Par exemple, dans l'énumération suivante, Sat est 0, Sun est 1, Mon est 2, etc.
enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};
Les énumérateurs peuvent utiliser des initialiseurs pour remplacer les valeurs par défaut, comme indiqué dans l'exemple suivant.
enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
Dans cette énumération, la séquence des éléments est forcée à commencer à 1 au lieu de 0. Toutefois, il est recommandé d'inclure une constante qui a la valeur 0. Pour plus d'informations, consultez Types énumération (Guide de programmation C#).
Chaque type d'énumération a un type sous-jacent qui peut être n'importe quel type intégral sauf 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 un octet (page éventuellement en anglais), utilisez le signe deux-points après l'identificateur suivi du type, comme illustré dans l'exemple suivant.
enum Days : byte {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
Les types approuvés pour un enum sont byte, sbyte, short, ushort, int, uint, long ou ulong.
Une variable de type Days peut recevoir n'importe quelle valeur dans la plage du type sous-jacent ; les valeurs ne sont pas limitées aux constantes nommées.
La valeur par défaut d'un élément enum E correspond au résultat de l'expression (E)0.
Notes
Le nom d'un énumérateur ne peut pas contenir d'espace blanc.
Le type sous-jacent spécifie le stockage alloué à chaque énumérateur. Toutefois, une conversion explicite doit être utilisée pour convertir un type enum en type intégral. Par exemple, l'instruction suivante assigne l'énumérateur Sun à une variable du type int en utilisant un cast pour convertir l'enum en int.
int x = (int)Days.Sun;
Lorsque vous appliquez FlagsAttribute à une énumération qui contient des éléments combinés à une opération de bits OR, vous remarquez que l'attribut affecte le comportement de l'enum lorsqu'il est utilisé avec certains outils. Vous pouvez remarquer ces modifications lorsque vous utilisez des outils tels que les méthodes de classe de Console et l'évaluateur d'expression. (Consultez le troisième exemple.)
Programmation fiable
Comme avec toute constante, toutes les références aux valeurs individuelles d'un enum sont converties en littéraux numériques au moment de la compilation. Cela peut créer des problèmes de contrôle de version comme décrit dans Constantes (Guide de programmation C#).
L'assignation de valeurs supplémentaires à de nouvelles versions d'enums ou la modification des valeurs des membres enum dans une nouvelle version peut poser des problèmes pour le code source dépendant. Les valeurs enum sont souvent utilisées dans les instructions switch. Si des éléments supplémentaires ont été ajoutés au type enum, la section par défaut de l'instruction switch peut être sélectionnée de façon inattendue.
Si d'autres développeurs utilisent votre code, il convient de leur fournir des indications sur la façon dont leur code doit réagir si de nouveaux éléments sont ajoutés à des types enum.
Exemple
Dans l'exemple suivant, une énumération, Days, est déclarée. Deux énumérateurs sont explicitement convertis en entiers et assignés à des variables.
public class EnumTest
{
enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
static void Main()
{
int x = (int)Days.Sun;
int y = (int)Days.Fri;
Console.WriteLine("Sun = {0}", x);
Console.WriteLine("Fri = {0}", y);
}
}
/* Output:
Sun = 0
Fri = 5
*/
Dans cet exemple, l'option de type de base est utilisée pour déclarer une enum dont les membres sont de type long. Remarquez que bien que le type sous-jacent de l'énumération soit long, les membres de l'énumération doivent encore être convertis explicitement en type long à l'aide d'un 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
*/
L'exemple de code suivant illustre l'utilisation et les effets de l'attribut FlagsAttribute sur une déclaration enum.
// 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
*/
Commentaires
Si vous supprimez Flags, l'exemple affiche les valeurs suivantes :
5
5
Spécification du langage C#
Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
Voir aussi
Référence
Tableau des types intégraux (référence C#)
Tableau des types intégrés (référence C#)
Tableau des conversions numériques implicites (référence C#)
Tableau des conversions numériques explicites (référence C#)
Concepts
Types énumération (Guide de programmation C#)