Is there another way to test Enum bit fields?

Question

When using Enums with bit fields:

   enum  ReallyBigEnum  { FirstChoice = 0x01, AnotherOption = 0x02 }
   ReallyBigEnum  flag = ReallyBigEnum.FirstChoice | ReallyBigEnum.AnotherOption;

the code used to test the bits is:

   if( (flag & ReallyBigEnum.AnotherOption) == ReallyBigEnum.AnotherOption ) { ... }

which seems verbose and error prone because of the need to repeat the bit being tested.

It would be nice if there were some way to say:

   if( flag.IsSet( ReallyBigEnum.AnotherOption ) ) { ... }

but Enums don't support instance methods. So, I tried a template function:

   class Enums
   {
      public static bool IsSet<T>( T flag, T bit ) { return (flag & bit) == bit; }
   }

but the code to test bits then looks like this:

   if( Enums.IsSet<ReallyBigEnum>( flag, ReallyBigEnum.AnotherOption ) ) { ... }

which is a lot to write. Then I tried to shorten it:

   class Enums
   {
      public static bool IsSet( int flag, int bit ) { return (flag & bit) == bit; }
   }

but then you have to cast each value to its base type like this:

   if( Enums.IsSet( (int)flag, (int)ReallyBigEnum.AnotherOption ) ) { ... }

which is also a pain to code and loses the benefit of type checking.

The same function could be written to use 'object' parameters, but then the object type and underlying base type would have to be tested.

So, I'm stuck with the standard, redundant way at the top.

Does anyone have other ideas on a clean, simple way of testing Enum bit fields?

Much Thanks.

Answer 1

Up to .Net 3.5 this is your only option. In .Net 4.0 there is a HasFlag method on the enum.

Answer 2

if((flag & ReallyBigEnum.AnotherOption) != 0) { ... }

UPDATED:

The above obviously work only if you're testing a single bit. If you want to test multiple bits, then something else is required, depending on whether you are checking for all bits or any bit.

Testing that any of a set of bits is set

For this case, just use a variant of the single bit version.

if((flag & (ReallyBigEnum.FirstOption | ReallyBigEnum.AnotherOption)) != 0) { ... }

Testing that all of a set of bits is set

For this case to achive clarity and reliability, I suggest creating a constant that contains all of the bits.

const int ReallyBigEnum WickedAwesomeOptions = ReallyBigEnum.FirstOption | ReallyBigEnum.AnotherOption;
...
if (flag & WickedAwesomeOptions == WickedAwesomeOptions) { ... }

Some of the redundancy is still there, but it is not fragile or confusing, and it is easy to maintain.

If the bit combination applies broadly, then you can add it to the enum itself.

[Flags]
enum ReallyBigEnum
{
    FirstOption = 1,
    AnotherOption = 2,
    WickedAwesomeOptions = FirstOption | AnotherOption,
}
....
if (flag & ReallyBigEnum.WickedAwesomeOptions == ReallyBigEnum.WickedAwesomeOptions) { ... }

Answer 3

/// <summary>
/// Taken from https://stackoverflow.com/questions/9033/hidden-features-of-c/407325#407325
/// instead of doing (enum & value) == value you can now use enum.Has(value)
/// </summary>
/// <typeparam name="T">Type of enum</typeparam>
/// <param name="type">The enum value you want to test</param>
/// <param name="value">Flag Enum Value you're looking for</param>
/// <returns>True if the type has value bit set</returns>
public static bool Has<T>(this System.Enum type, T value)
{
   return (((int)(object)type & (int)(object)value) == (int)(object)value);
} 

Here is an Extension Method I took from the above link

Use:

MyFlagEnum e = MyFlagEnum.First | MyFlagEnum.Second;
if(e.Has(MyFlagEnum.First))
{
   // Do stuff
}