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

ID : 681

viewed : 395

Tags : c#enumsflagsc#





Top 5 Answer for What does the [Flags] Enum Attribute mean in C#?

vote vote

92

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 & MyColor.Yellow) == MyColor.Yellow) {     // Yellow is allowed... }  if((myProperties.AllowedColors & 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 & 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

vote vote

88

You can also do this

[Flags] public enum MyEnum {     None   = 0,     First  = 1 << 0,     Second = 1 << 1,     Third  = 1 << 2,     Fourth = 1 << 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

vote vote

79

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 << 0,   // 1     Two     = 1 << 1,   // 2     Three   = 1 << 2,   // 4     Four    = 1 << 3,   // 8      // combinations     OneAndTwo = One | Two,     OneTwoAndThree = One | Two | Three, } 

You can declare

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

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 
vote vote

67

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 & MyFlags.Foo) == MyFlags.Foo)             {                 Console.WriteLine("Item has Foo flag set");             }         }     } } 
vote vote

53

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.

Top 3 video Explaining What does the [Flags] Enum Attribute mean in C#?







Related QUESTION?