What does the Flags Enum Attribute mean in C

Question

From time to time I see an enum like the following    Flags  public enum Options        None      0      Option1   1      Option2   2      Option3   4      Option4   8     I don t understand what exactly the  Flags  attribute does   Anyone have a good explanation or example they could post

User · Answer

Nidonocu  To add another flag to an existing set of values  use the OR assignment operator   Mode   Mode Read    Add Mode Write Mode    Mode Write  Assert True   Mode  amp  Mode Write     Mode Write     amp  amp    Mode  amp  Mode Read     Mode Read

User · Answer

Flags allow you to use bitmasking inside your enumeration   This allows you to combine enumeration values  while retaining which ones are specified    Flags  public enum DashboardItemPresentationProperties   long       None   0      HideCollapse   1      HideDelete   2      HideEdit   4      HideOpenInNewWindow   8      HideResetSource   16      HideMenu   32

User · Answer

Flags are used when an enumerable value represents a collection of enum members   here we use bitwise operators    and  amp   Example               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

User · Answer

In extension to the accepted answer  in C 7 the enum flags can be written using binary literals    Flags  public enum MyColors       None     0b0000      Yellow   0b0001      Green    0b0010      Red      0b0100      Blue     0b1000     I think this representation makes it clear how the flags work under the covers

User · Answer

Combining answers https   stackoverflow com a 8462 1037948  declaration via bit-shifting  and https   stackoverflow com a 9117 1037948  using combinations in declaration  you can bit-shift previous values rather than using numbers   Not necessarily recommending it  but just pointing out you can   Rather than    Flags  public enum Options   byte       None      0      One       1  lt  lt  0       1     Two       1  lt  lt  1       2     Three     1  lt  lt  2       4     Four      1  lt  lt  3       8         combinations     OneAndTwo   One   Two      OneTwoAndThree   One   Two   Three      You can declare   Flags  public enum Options   byte       None      0      One       1  lt  lt  0           1        now that value 1 is available  start shifting from there     Two       One  lt  lt  1         2     Three     Two  lt  lt  1         4     Four      Three  lt  lt  1       8         same combinations     OneAndTwo   One   Two      OneTwoAndThree   One   Two   Three        Confirming with LinqPad   foreach var e in Enum GetValues typeof Options          string Format   0     1    e ToString     byte e  Dump        Results in   None   0 One   1 Two   2 OneAndTwo   3 Three   4 OneTwoAndThree   7 Four   8

User · Answer

To add Mode Write   Mode   Mode   Mode Write

User · Answer

When working with flags I often declare additional None and All items  These are helpful to check whether all flags are set or no flag is set     Flags   enum SuitsFlags         None       0       Spades     1  lt  lt  0       Clubs      1  lt  lt  1       Diamonds   1  lt  lt  2       Hearts     1  lt  lt  3       All           0  lt  lt  4       Usage   Spades   Clubs   Diamonds   Hearts    All     true Spades  amp  Clubs    None     true    nbsp  Update 2019-10   Since C  7 0 you can use binary literals  which are probably more intuitive to read    Flags   enum SuitsFlags         None       0b0000       Spades     0b0001       Clubs      0b0010       Diamonds   0b0100       Hearts     0b1000       All        0b1111

User · Answer

The  Flags  attribute should be used whenever the enumerable represents a collection of possible values  rather than a single value  Such collections are often used with bitwise operators  for example   var allowedColors   MyColor Red   MyColor Green   MyColor Blue    Note that the  Flags  attribute doesn t enable this by itself - all it does is allow a nice representation by the  ToString   method   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    It is also important to note that  Flags  does not automatically make the enum values powers of two  If you omit the numeric values  the enum will not work as one might expect in bitwise operations  because by default the values start with 0 and increment    Incorrect declaration    Flags  public enum MyColors       Yellow      0     Green       1     Red         2     Blue        3     The values  if declared this way  will be Yellow   0  Green   1  Red   2  Blue   3  This will render it useless as flags   Here s an example of a correct declaration    Flags  public enum MyColors       Yellow   1      Green   2      Red   4      Blue   8     To retrieve the distinct values in your property  one can do this   if  myProperties AllowedColors HasFlag MyColor Yellow            Yellow is allowed        or prior to  NET 4   if  myProperties AllowedColors  amp  MyColor Yellow     MyColor Yellow           Yellow is allowed       if  myProperties AllowedColors  amp  MyColor Green     MyColor Green           Green is allowed            Under the covers  This works because you used powers of two in your enumeration  Under the covers  your enumeration values look like this in binary ones and zeros    Yellow  00000001  Green   00000010  Red     00000100  Blue    00001000   Similarly  after you ve set your property AllowedColors to Red  Green and Blue using the binary bitwise OR   operator  AllowedColors looks like this   myProperties AllowedColors  00001110   So when you retrieve the value you are actually performing bitwise AND  amp  on the values   myProperties AllowedColors  00001110              MyColor Green  00000010              -----------------------                             00000010    Hey  this is the same as MyColor Green    The None   0 value  And regarding the use of 0 in your enumeration  quoting from MSDN    Flags  public enum MyColors       None   0                  Use None as the name of the flag enumerated constant whose value is zero  You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero  However  you can perform a logical  not a bitwise  comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set     You can find more info about the flags attribute and its usage at msdn and designing flags at msdn

User · Answer

Please see the following for an example which shows the declaration and potential usage   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  amp  MyFlags Foo     MyFlags Foo                                Console WriteLine  Item has Foo flag set

User · Answer

I asked recently about something similar   If you use flags you can add an extension method to enums to make checking the contained flags easier  see post for detail   This allows you to do    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              Then you can do   PossibleOptions opt   PossibleOptions OptionOneTwoAndThree   if  opt IsSet  PossibleOptions OptionOne             optionOne is one of those set     I find this easier to read than the most ways of checking the included flags

User · Answer

There s something overly verbose to me about the if   x  amp  y     y     construct  especially if x AND y are both compound sets of flags and you only want to know if there s any overlap   In this case  all you really need to know is if there s a non-zero value 1  after you ve bitmasked         1  See Jaime s comment   If we were authentically bitmasking  we d   only need to check that the result was positive   But since enums   can be negative  even  strangely  when combined with the  Flags    attribute    it s defensive to code for    0 rather than  gt  0    Building off of  andnil s setup     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  amp  MyColor Blue     0          True             Console WriteLine  myColor  amp  MyColor Red     0           False                             Console WriteLine  myColor  amp  acceptableColors     0      True                    though only Yellow is shared               Console WriteLine  myColor  amp  MyColor Green     0         Wait a minute      D              Console Read

User · Answer

You can also do this   Flags  public enum MyEnum       None     0      First    1  lt  lt  0      Second   1  lt  lt  1      Third    1  lt  lt  2      Fourth   1  lt  lt  3     I find the bit-shifting easier than typing 4 8 16 32 and so on  It has no impact on your code because it s all done at compile time

User · Answer

Apologies if someone already noticed this scenario  A perfect example of flags we can see in reflection  Yes Binding Flags ENUM   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  quot Invoking a static method  quot    Console WriteLine  quot ------------------------- quot    t InvokeMember   quot SayHello quot   BindingFlags InvokeMethod   BindingFlags Public        BindingFlags Static  null  null  new object

[c#] What does the [Flags] Enum Attribute mean in C#?

Examples related to c#

Examples related to enums

Examples related to flags