11. Enumérations

Les énumérations (enum) spécifient un groupe un groupe de constantes numériques nommées.
les membres des énumérations doivent être utilisés avec le nom du type de l'énumération.
Par défaut, les énumérations sont assignées avec des constantes entières 0, 1, 2, etc. Vous pouvez cependant spécifier un autre type numérique pour poser votre énumération et explicitement spécifier les valeurs pour chacun de ses membres.
Code Résultat Remarques 
using System;

namespace Exemples
{
    public enum Direction { Nord, Est, Ouest, Sud }
    [Flags]
    public enum DirectionByte : byte { Nord=1, Est=2, Ouest=4, Sud=8 }
    class Enumerations1
    {
        static void Main(string[] args)
        {
            Direction murs = Direction.Est;
            Console.WriteLine(murs); // affiche Est
            Console.WriteLine((int)murs); // affiche 1
            DirectionByte mursByte = DirectionByte.Nord | DirectionByte.Ouest ;
            Console.WriteLine(mursByte); // affiche Nord, Ouest
            Console.WriteLine((byte)mursByte); // affiche 5
            if ((mursByte & DirectionByte.Nord) != 0)
                Console.WriteLine("Ne peut pas aller au nord !"); // affiche Ne peut pas aller au nord !
            Console.ReadKey();
        }
    }
}
 
Est
1
Nord, Ouest
5
Ne peut pas aller au nord !
 L'attribut [Flags] est optionnel et informe l'environnement d'application que les valeurs dans l'énumération peuvent être combinées bit à bit et doivent être décodées en accord avec le débogueur ou lors de sorties de texte sur la console.
Le type System.Enum fournit également quelques méthodes statiques utiles pour les énumérations qui vous permettent de déterminer le type de base d'une énumération, de vérifier si une valeur spécifique est supportée, d'initialiser l'énumération d'une chaîne de caractères constante, de retrouver une liste de valeurs valides et d'autres opérations communes telles que les conversions.
Code Résultat Remarques 
using System;

namespace Exemples
{
    public enum Bascule : byte { Non = 0, Oui = 1 }
    class Enumerations2
    {
        static void Main(string[] args)
        {
            Type t = Enum.GetUnderlyingType(typeof(Bascule));
            Console.WriteLine(typeof(Bascule)); // affiche Exemples.Bascule
            Console.WriteLine(t); // affiche System.Byte
            bool bVrai = Enum.IsDefined(typeof(Bascule), "Vrai");
            Console.WriteLine(bVrai); // affiche False
            bool bOui = Enum.IsDefined(typeof(Bascule), "Oui");
            Console.WriteLine(bOui); // affiche True
            Bascule bas = (Bascule)Enum.Parse(typeof(Bascule), "Oui");
            Console.WriteLine(bas); // affiche Oui
            Console.WriteLine(Enum.Format(typeof(Bascule), bas, "D")); // affiche 1;
            Array ab = Enum.GetValues(typeof(Bascule));
            foreach (Bascule bascule in ab) // affiche Non = 0 et Oui = 1
                Console.WriteLine("{0} = {1}", bascule, Enum.Format(typeof(Bascule), bascule, "D"));
            Console.ReadKey();
        }
    }
}
 
Exemples.Bascule
System.Byte
False
True
Oui
1
Non = 0
Oui = 1
 Voilà des exemples d'utilisation des méthodes statiques de System.Enum.

11.1. Opérateurs des énumérations

Les opérateurs applicables aux énumérations sont les suivants :

11.2. Convertir des énumérations

Les énumérations peuvent être converties explicitement en d'autres énumérations.Les énumérations et les types numériques peuvent être convertis explicitement les uns en les autres. le numérique littéral 0 est un cas à part, qui peut être converti implicitement en une énumération.

Pour plus d'information :
Enum, classe : http://msdn.microsoft.com/fr-fr/library/system.enum.aspx