Que signifie l'attribut [Flags] Enum en C #?

De temps en temps, je vois une énumération comme celle-ci:

[Flags]
public enum Options 
{
    None    = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    Option4 = 8
}

Je ne comprends pas exactement ce que fait l' [Flags]attribut.

Quelqu'un at-il une bonne explication ou un exemple qu'il pourrait publier?

L' [Flags]attribut doit être utilisé chaque fois que l'énumérable représente une collection de valeurs possibles, plutôt qu'une seule valeur. Ces collections sont souvent utilisées avec des opérateurs au niveau du bit, par exemple:

var allowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;

Notez que l' [Flags]attribut ne permet pas cela par lui-même - tout ce qu'il fait est de permettre une belle représentation par la .ToString()méthode:

enum Suits { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
[Flags] enum SuitsFlags { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }

...

var str1 = (Suits.Spades | Suits.Diamonds).ToString();
           // "5"
var str2 = (SuitsFlags.Spades | SuitsFlags.Diamonds).ToString();
           // "Spades, Diamonds"

Il est également important de noter que les valeurs d'énumération [Flags] ne sont pas automatiquement égales à deux. Si vous omettez les valeurs numériques, l'énumération ne fonctionnera pas comme on pourrait s'y attendre dans les opérations au niveau du bit, car par défaut, les valeurs commencent par 0 et incrémentent.

Déclaration incorrecte:

[Flags]
public enum MyColors
{
    Yellow,  // 0
    Green,   // 1
    Red,     // 2
    Blue     // 3
}

Les valeurs, si elles sont déclarées de cette façon, seront Jaune = 0, Vert = 1, Rouge = 2, Bleu = 3. Cela le rendra inutile en tant que drapeaux.

Voici un exemple de déclaration correcte:

[Flags]
public enum MyColors
{
    Yellow = 1,
    Green = 2,
    Red = 4,
    Blue = 8
}

Pour récupérer les valeurs distinctes de votre propriété, on peut le faire:

if (myProperties.AllowedColors.HasFlag(MyColor.Yellow))
{
    // Yellow is allowed...
}

ou avant .NET 4:

if((myProperties.AllowedColors & MyColor.Yellow) == MyColor.Yellow)
{
    // Yellow is allowed...
}

if((myProperties.AllowedColors & MyColor.Green) == MyColor.Green)
{
    // Green is allowed...
}    

Sous les couvertures

Cela fonctionne parce que vous avez utilisé des pouvoirs de deux dans votre énumération. Sous les couvertures, vos valeurs d'énumération ressemblent à ceci en binaires et en zéros:

 Yellow: 00000001
 Green:  00000010
 Red:    00000100
 Blue:   00001000

De même, une fois que vous avez défini votre propriété AllowedColors sur Rouge, Vert et Bleu à l'aide de l' |opérateur binaire OR au niveau du bit , AllowedColors ressemble à ceci:

myProperties.AllowedColors: 00001110

Ainsi, lorsque vous récupérez la valeur que vous effectuez réellement au niveau du bit ET &sur les valeurs:

myProperties.AllowedColors: 00001110
             MyColor.Green: 00000010
             -----------------------
                            00000010 // Hey, this is the same as MyColor.Green!

La valeur None = 0

Et concernant l'utilisation de 0dans votre énumération, citant MSDN:

[Flags]
public enum MyColors
{
    None = 0,
    ....
}

Utilisez None comme nom de la constante énumérée d'indicateur dont la valeur est zéro. Vous ne pouvez pas utiliser la constante énumérée None dans une opération AND au niveau du bit pour tester un indicateur car le résultat est toujours zéro. Cependant, vous pouvez effectuer une comparaison logique, et non pas au niveau du bit, entre la valeur numérique et la constante énumérée Aucune pour déterminer si des bits de la valeur numérique sont définis.

Vous pouvez trouver plus d'informations sur l'attribut flags et son utilisation sur msdn et sur la conception de flags sur msdn

Vous pouvez aussi faire ça

[Flags]
public enum MyEnum
{
    None   = 0,
    First  = 1 << 0,
    Second = 1 << 1,
    Third  = 1 << 2,
    Fourth = 1 << 3
}

Je trouve le décalage de bits plus facile que de taper 4,8,16,32 et ainsi de suite. Cela n'a aucun impact sur votre code car tout est fait au moment de la compilation

En combinant les réponses https://stackoverflow.com/a/8462/1037948 (déclaration par décalage de bits) et https://stackoverflow.com/a/9117/1037948 (en utilisant des combinaisons dans la déclaration), vous pouvez plutôt décaler les valeurs précédentes que d'utiliser des chiffres. Pas nécessairement le recommander, mais juste en soulignant que vous pouvez.

Plutôt que:

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,   // 1
    Two     = 1 << 1,   // 2
    Three   = 1 << 2,   // 4
    Four    = 1 << 3,   // 8

    // combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

Vous pouvez déclarer

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,       // 1
    // now that value 1 is available, start shifting from there
    Two     = One << 1,     // 2
    Three   = Two << 1,     // 4
    Four    = Three << 1,   // 8

    // same combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

Confirmation avec LinqPad:

foreach(var e in Enum.GetValues(typeof(Options))) {
    string.Format("{0} = {1}", e.ToString(), (byte)e).Dump();
}

Résulte en:

None = 0
One = 1
Two = 2
OneAndTwo = 3
Three = 4
OneTwoAndThree = 7
Four = 8

Veuillez consulter ce qui suit pour un exemple qui montre la déclaration et l'utilisation potentielle:

namespace Flags
{
    class Program
    {
        [Flags]
        public enum MyFlags : short
        {
            Foo = 0x1,
            Bar = 0x2,
            Baz = 0x4
        }

        static void Main(string[] args)
        {
            MyFlags fooBar = MyFlags.Foo | MyFlags.Bar;

            if ((fooBar & MyFlags.Foo) == MyFlags.Foo)
            {
                Console.WriteLine("Item has Foo flag set");
            }
        }
    }
}

En extension à la réponse acceptée, en C # 7 les drapeaux enum peuvent être écrits en utilisant des littéraux binaires:

[Flags]
public enum MyColors
{
    None   = 0b0000,
    Yellow = 0b0001,
    Green  = 0b0010,
    Red    = 0b0100,
    Blue   = 0b1000
}

Je pense que cette représentation montre clairement comment les drapeaux fonctionnent sous les couvertures .

J'ai demandé récemment quelque chose de similaire.

Si vous utilisez des indicateurs, vous pouvez ajouter une méthode d'extension aux énumérations pour faciliter la vérification des indicateurs contenus (voir l'article pour plus de détails)

Cela vous permet de faire:

[Flags]
public enum PossibleOptions : byte
{
    None = 0,
    OptionOne = 1,
    OptionTwo = 2,
    OptionThree = 4,
    OptionFour = 8,

    //combinations can be in the enum too
    OptionOneAndTwo = OptionOne | OptionTwo,
    OptionOneTwoAndThree = OptionOne | OptionTwo | OptionThree,
    ...
}

Ensuite, vous pouvez faire:

PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree 

if( opt.IsSet( PossibleOptions.OptionOne ) ) {
    //optionOne is one of those set
}

Je trouve cela plus facile à lire que la plupart des façons de vérifier les drapeaux inclus.

@Nidonocu

Pour ajouter un autre indicateur à un ensemble de valeurs existant, utilisez l'opérateur d'affectation OU.

Mode = Mode.Read;
//Add Mode.Write
Mode |= Mode.Write;
Assert.True(((Mode & Mode.Write) == Mode.Write)
  && ((Mode & Mode.Read) == Mode.Read)));

Lorsque je travaille avec des drapeaux, je déclare souvent des éléments supplémentaires Aucun et Tous. Ces informations sont utiles pour vérifier si tous les indicateurs sont définis ou si aucun indicateur n'est défini.

[Flags] 
enum SuitsFlags { 

    None =     0,

    Spades =   1 << 0, 
    Clubs =    1 << 1, 
    Diamonds = 1 << 2, 
    Hearts =   1 << 3,

    All =      ~(~0 << 4)

}

Usage:

Spades | Clubs | Diamonds | Hearts == All  // true
Spades & Clubs == None  // true

 
Mise à jour 2019-10:

Depuis C # 7.0, vous pouvez utiliser des littéraux binaires, qui sont probablement plus intuitifs à lire:

[Flags] 
enum SuitsFlags { 

    None =     0b0000,

    Spades =   0b0001, 
    Clubs =    0b0010, 
    Diamonds = 0b0100, 
    Hearts =   0b1000,

    All =      0b1111

}

Pour ajouter Mode.Write:

Mode = Mode | Mode.Write;

Il y a quelque chose de trop verbeux dans la if ((x & y) == y)...construction, surtout si xET ysont tous deux des ensembles composés de drapeaux et que vous voulez seulement savoir s'il y a un chevauchement.

Dans ce cas, tout ce que vous devez vraiment savoir, c'est s'il y a une valeur non nulle [1] après avoir masqué le bit .

[1] Voir le commentaire de Jaime. Si nous faisions du masquage de bit authentiquement , nous n'aurions qu'à vérifier que le résultat était positif. Mais puisque enums peut être négatif, même étrangement, lorsqu'il est combiné avec l' [Flags] attribut , il est défensif de coder != 0plutôt que > 0.

Construire à partir de la configuration de @ andnil ...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BitFlagPlay
{
    class Program
    {
        [Flags]
        public enum MyColor
        {
            Yellow = 0x01,
            Green = 0x02,
            Red = 0x04,
            Blue = 0x08
        }

        static void Main(string[] args)
        {
            var myColor = MyColor.Yellow | MyColor.Blue;
            var acceptableColors = MyColor.Yellow | MyColor.Red;

            Console.WriteLine((myColor & MyColor.Blue) != 0);     // True
            Console.WriteLine((myColor & MyColor.Red) != 0);      // False                
            Console.WriteLine((myColor & acceptableColors) != 0); // True
            // ... though only Yellow is shared.

            Console.WriteLine((myColor & MyColor.Green) != 0);    // Wait a minute... ;^D

            Console.Read();
        }
    }
}

Les indicateurs vous permettent d'utiliser le masquage de bit à l'intérieur de votre énumération. Cela vous permet de combiner les valeurs d'énumération, tout en conservant celles qui sont spécifiées.

[Flags]
public enum DashboardItemPresentationProperties : long
{
    None = 0,
    HideCollapse = 1,
    HideDelete = 2,
    HideEdit = 4,
    HideOpenInNewWindow = 8,
    HideResetSource = 16,
    HideMenu = 32
}

Toutes mes excuses si quelqu'un a déjà remarqué ce scénario. Un parfait exemple de drapeaux que nous pouvons voir en réflexion. Oui Binding Flags ENUM. https://docs.microsoft.com/en-us/dotnet/api/system.reflection.bindingflags?view=netframework-4.8

[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum BindingFlags

Usage

             // BindingFlags.InvokeMethod
            // Call a static method.
            Type t = typeof (TestClass);

            Console.WriteLine();
            Console.WriteLine("Invoking a static method.");
            Console.WriteLine("-------------------------");
            t.InvokeMember ("SayHello", BindingFlags.InvokeMethod | BindingFlags.Public | 
                BindingFlags.Static, null, null, new object [] {});