Ce înseamnă atributul Enum [Flags] în C#?

Atributul [Flags] ar trebui utilizat ori de câte ori enumerabilul reprezintă o colecție de valori posibile, mai degrabă decât o singură valoare. Astfel de colecții sunt adesea folosite cu operatori pe biți, de exemplu:

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

Rețineți că atributul [Flags] nu permite acest lucru de la sine - tot ce face este să permită o reprezentare frumoasă prin metoda .ToString():

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"

De asemenea, este important să rețineți că [Flags] nu face automat valorile enumerate cu puteri de două. Dacă omiteți valorile numerice, enumerarea nu va funcționa așa cum s-ar putea aștepta în operațiunile pe biți, deoarece valorile încep implicit cu 0 și cresc.

Declarație incorectă:

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

Valorile, dacă sunt declarate astfel, vor fi Galben = 0, Verde = 1, Roșu = 2, Albastru = 3. Acest lucru îl va face inutil ca steaguri.

Iată un exemplu de declarație corectă:

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

Pentru a prelua valorile distincte din proprietatea dvs., puteți proceda astfel:

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

sau înainte de .NET 4:

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

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

Sub huse

Acest lucru funcționează deoarece ați folosit puteri de doi în enumerarea dvs. Sub coperte, valorile dvs. de enumerare arată astfel în numere binare și zerouri:

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

În mod similar, după ce ați setat proprietatea AllowedColors la Roșu, Verde și Albastru folosind operatorul binar SAU |, AllowedColors arată astfel:

myProperties.AllowedColors: 00001110

Deci, atunci când recuperați valoarea, efectuați de fapt pe biți și & pe valori:

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

Valoarea Niciunul = 0

Și în ceea ce privește utilizarea lui 0 în enumerarea dvs., citând din MSDN:

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

Utilizați None ca nume al constantei enumerate de flag a cărei valoare este zero. Nu puteți utiliza constanta enumerată None într-o operație AND pe biți pentru a testa un indicator, deoarece rezultatul este întotdeauna zero. Totuși, puteți efectua o comparație logică, nu pe biți, între valoarea numerică și Nicio constantă enumerată pentru a determina dacă sunt setați biți din valoarea numerică.

Puteți găsi mai multe informații despre atributul flags și despre utilizarea acestuia la msdn și proiectarea steaguri la msdn

De asemenea, puteți face acest lucru

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

Mi se pare că deplasarea biților este mai ușoară decât tastarea 4,8,16,32 și așa mai departe. Nu are niciun impact asupra codului dvs., deoarece totul este făcut în timpul compilării

Combinarea răspunsurilor https://stackoverflow.com/a/8462/1037948 (declarație prin deplasare de biți) și https://stackoverflow.com/a/9117/1037948 (folosind combinații în declarație) puteți deplasa biți valorile anterioare în loc să utilizați numere. Nu îl recomand neapărat, ci doar indicând că poți.

Mai degrabă decât:

[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,
}

Poti declara

[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,
}

Confirmare cu LinqPad:

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

Rezultate în:

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

Consultați următoarele pentru un exemplu care arată declarația și utilizarea potențială:

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");
            }
        }
    }
}

În extensie la răspunsul acceptat, în C#7 steagurile de enumerare pot fi scrise folosind literale binare:

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

Cred că această reprezentare arată clar cum funcționează steagurile sub copertă.

Am am întrebat recent despre ceva asemanator.

Dacă utilizați steaguri, puteți adăuga o metodă de extensie la enums pentru a ușura verificarea steaguri conținute (vezi postarea pentru detalii)

Acest lucru vă permite să faceți:

[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,
    ...
}

Atunci poți face:

PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree 

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

Mi se pare mai ușor de citit decât cele mai multe moduri de a verifica steagurile incluse.

Când lucrez cu steaguri, declar adesea articole suplimentare Nici unul și Toate. Acestea sunt utile pentru a verifica dacă toate steagurile sunt setate sau nu este setat niciun steag.

[Flags] 
enum SuitsFlags { 

    None =     0,

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

    All =      ~(~0 << 4)

}

Utilizare:

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

Actualizare 2019-10:

Începând cu C# 7.0, puteți utiliza literale binare, care sunt probabil mai intuitiv de citit:

[Flags] 
enum SuitsFlags { 

    None =     0b0000,

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

    All =      0b1111

}

@Nidonocu

Pentru a adăuga un alt indicator la un set existent de valori, utilizați operatorul de atribuire OR.

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

Pentru a adăuga Mode.Write:

Mode = Mode | Mode.Write;

Pentru mine este ceva prea prolix în legătură cu constructul if ((x & y) == y)..., mai ales dacă x ȘI y sunt ambele seturi compuse de steaguri și vrei să știi doar dacă există o suprapunere.

În acest caz, tot ce trebuie să știți este dacă există o valoare diferită de zero[1] după ce ați mascat biți.

[1] Vezi comentariul lui Jaime. Dacă am fi bitmasking în mod autentic, ar trebui doar să verificăm dacă rezultatul este pozitiv. Dar din moment ce enums pot fi negative, chiar și, în mod ciudat, atunci când sunt combinate cu atributul [Flags] , este defensiv să codificați pentru != 0 în loc de > 0.

Pornind de la configurația lui @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();
        }
    }
}

Steagurile vă permit să utilizați mascarea de biți în cadrul enumerației dvs. Acest lucru vă permite să combinați valorile de enumerare, păstrând în același timp care sunt specificate.

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

Scuze dacă cineva a observat deja acest scenariu. Un exemplu perfect de steaguri pe care îl putem vedea în reflecție. Da Binding Flags ENUM .

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

Utilizare

// 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 [] {});

• Indicatoarele sunt utilizate atunci când o valoare enumerabilă reprezintă o colecție de membri enumerați.

• aici folosim operatori pe biți, | și &

• Exemplu

               [Flags]
               public enum Sides { Left=0, Right=1, Top=2, Bottom=3 }
  
               Sides leftRight = Sides.Left | Sides.Right;
               Console.WriteLine (leftRight);//Left, Right
  
               string stringValue = leftRight.ToString();
               Console.WriteLine (stringValue);//Left, Right
  
               Sides s = Sides.Left;
               s |= Sides.Right;
               Console.WriteLine (s);//Left, Right
  
               s ^= Sides.Right; // Toggles Sides.Right
               Console.WriteLine (s); //Left