Que signifie L'attribut [Flags] Enum dans C#?

, Vous pouvez aussi le faire

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

je trouve le bit-shifting 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

Combining answers https://stackoverflow.com/a/8462/1037948 (déclaration par bit-shifting) et https://stackoverflow.com/a/9117/1037948 (en utilisant des combinaisons dans la déclaration) vous pouvez bit-shift valeurs précédentes plutôt que d'utiliser des nombres. Je ne le recommande pas nécessairement, mais je vous signale que vous le 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ésultats dans:

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

veuillez consulter l'exemple suivant 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");
            }
        }
    }
}

I a demandé récemment à propos de quelque chose de similaire.

si vous utilisez des drapeaux, vous pouvez ajouter une méthode d'extension à enums pour faciliter la vérification des drapeaux contenus (voir post 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,
    ...
}

alors 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, utilisez l'opérateur d'affectation.

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

en extension à la réponse acceptée, dans C#7 les drapeaux enum peuvent être écrits en utilisant des lettres 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 .

pour ajouter Mode.Write :

Mode = Mode | Mode.Write;

il y a quelque chose d'exagérément verbeux pour moi au sujet de la construction if ((x & y) == y)... , surtout si x et y sont deux ensembles composés de drapeaux et vous voulez seulement savoir s'il y a tout chevauchement .

dans ce cas, tout ce que vous devez savoir est s'il y a une valeur non-nulle[1] après avoir bitmasked .

[1] voir le commentaire de Jaime. Si nous étions authentiques bitmasking , il suffit de vérifier que le résultat était positif. Mais depuis enum s peut être négatif, même, étrangement, lorsqu'il est combiné avec le [Flags] attribut , c'est défensif de coder pour != 0 plutôt que > 0 .

Construit à 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();
        }
    }
}

vous permettent d'utiliser bitmasking à l'intérieur de votre énumération. Cela vous permet de combiner des 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
}