How to check if any flags of a flag combination are set?

Question

Let's say I have this enum:

[Flags]
enum Letters
{
     A = 1,
     B = 2,
     C = 4,
     AB = A | B,
     All = A | B | C,
}

To check if for example AB is set I can do this:

if((letter & Letters.AB) == Letters.AB)

Is there a simpler way to check if any of the flags of a combined flag constant are set than the following?

if((letter & Letters.A) == Letters.A || (letter & Letters.B) == Letters.B)

Could one for example swap the & with something?

user_1279991 · Answer

In .NET 4 you can use the Enum.HasFlag method :

using System;

[Flags] public enum Pet {
   None = 0,
   Dog = 1,
   Cat = 2,
   Bird = 4,
   Rabbit = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three families: one without pets, one with dog + cat and one with a dog only
      Pet[] petsInFamilies = { Pet.None, Pet.Dog | Pet.Cat, Pet.Dog };
      int familiesWithoutPets = 0;
      int familiesWithDog = 0;

      foreach (Pet petsInFamily in petsInFamilies)
      {
         // Count families that have no pets. 
         if (petsInFamily.Equals(Pet.None))
            familiesWithoutPets++;
         // Of families with pets, count families that have a dog. 
         else if (petsInFamily.HasFlag(Pet.Dog))
            familiesWithDog++;
      }
      Console.WriteLine("{0} of {1} families in the sample have no pets.", 
                        familiesWithoutPets, petsInFamilies.Length);   
      Console.WriteLine("{0} of {1} families in the sample have a dog.", 
                        familiesWithDog, petsInFamilies.Length);   
   }
}

The example displays the following output:

//       1 of 3 families in the sample have no pets. 
//       2 of 3 families in the sample have a dog.

user_6726527 · Answer

You can use this extension method on enum, for any type of enums:

public static bool IsSingle(this Enum value)
{
    var items = Enum.GetValues(value.GetType());
    var counter = 0;
    foreach (var item in items)
    {
        if (value.HasFlag((Enum)item))
        {
            counter++;
        }
        if (counter > 1)
        {
            return false;
        }
    }
    return true;
}

user_9397635 · Answer

Starting with .Net 4, you can use a shorthand version without explicitly specifying &:

if(Letters.AB.HasFlag(Letters.C))

user_543814 · Answer

Can we find out easily and efficiently whether at least one flag is set?

Well, if you are satisfied with checking whether at least one flag bit is set, then yes!

Usage:

if (EnumHelper.HasAnyFlagBitsSet(letter))

Implementation:

public static class EnumHelper
{
    static EnumHelper()
    {
        // Required to get correct behavior in GetNumericValue
        // Because we will overlap the enum type with a ulong, left-aligned
        if (!BitConverter.IsLittleEndian)
            throw new NotSupportedException("This type is only supported on little-endian architectures.");
    }

    /// 
    /// 
    /// Returns whether the given enum value has any bits set that occurs in a defined flag for .
    /// 
    /// 
    /// Throws if the type parameter is not an enum type with the .
    /// 
    /// 
    public static bool HasAnyFlagBitsSet(T enumValue)
        where T : unmanaged, Enum
    {
        var numericValue = GetNumericValue(enumValue);

        // Take the value that has all the permitted bits set
        // Use & to keep only the corresponding bits from the input value
        // Check that the input value provided at least one such bit
        return (numericValue & FlagValueCache.AllFlagsSetValue) != 0;
    }

    /// 
    /// 
    /// Returns whether the given enum value has any bits set that are set in .
    /// 
    /// 
    /// Throws if the type parameter is not an enum type with the .
    /// 
    /// 
    public static bool HasAnyFlagBitsSet(T enumValue, T flags)
        where T : unmanaged, Enum
    {
        var numericValue = GetNumericValue(enumValue);
        var numericFlags = GetNumericValue(flags);

        // Use & to keep only the bits present in flags
        // Check that the input value provided at least one such bit
        return (numericValue & flags) != 0;
    }

    // Actually, have a bonus method as well, since this is a common operation:

    /// 
    /// 
    /// Returns whether the given enum value consists exclusively of defined flags for .
    /// The result is false if a bit is set that is not part of any value defined by .
    /// 
    /// 
    /// Throws if the type parameter is not an enum type with the .
    /// 
    /// 
    public static bool HasDefinedFlags(T enumValue)
        where T : unmanaged, Enum
    {
        var numericValue = GetNumericValue(enumValue);

        // Take the value that has all the permitted bits set
        // Use ~ to get a value with all the forbidden bits set
        // Use & to keep only the corresponding bits from the input value
        // Check that the input value provided no such forbidden bits
        return (numericValue & ~FlagValueCache.AllFlagsSetValue) == 0;
    }

    /// 
    /// 
    /// Returns the numeric value of the given .
    /// 
    /// 
    /// The resulting  can be cast to the intended integral type, even if it is a signed type.
    /// 
    /// 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong GetNumericValue(T enumValue)
        where T : unmanaged, Enum
    {
        Span ulongSpan = stackalloc ulong[] { 0UL };
        Span span = MemoryMarshal.Cast(ulongSpan);

        span[0] = enumValue;

        return ulongSpan[0];
    }

    /// 
    /// Statically caches a "full" flags value each enum type for which this class is accessed.
    /// 
    internal static class FlagValueCache
        where T : unmanaged, Enum
    {
        /// 
        /// Each bit that is set in any of the type's defined values is also set in this value.
        /// 
        public static ulong AllFlagsSetValue { get; }

        static FlagValueCache()
        {
            if (typeof(T).BaseType != typeof(Enum)) throw new Exception("The type parameter must be an enum type.");

            foreach (var value in (T[])Enum.GetValues(typeof(T)))
                AllFlagsSetValue |= GetNumericValue(value);
        }
    }
}

What does it mean that we are checking if at least one flag bit is set?

Well, this solution may fail to answer correctly for nonsensical enums like the following:

[Flags]
public enum Nonsense
{
    One = 1,

    // Eh, why does this value need TWO bits when those bits are NOT defined as individual values?
    TwoAndFour = 2 | 4,
}

Here, EnumHelper.HasAnyFlagBitSet((Nonsense)2) would return true, which is technically incorrect, since 2 is not a defined flag.

However, it works perfectly fine for all sensible flags enums, including ones with multi-flags:

[Flags]
public enum Fine
{
    One = 1,
    Two = 2,
    Four = 4,

    // Fine, and sensible, since these flags exist individually
    TwoAndFour = 2 | 4,
}

How to check if any flags of a flag combination are set?

18 Answers