C# Enum.HasFlag vs. Bitwise AND Operator Check

Question

If you have an enum that is used for bit flags, ie,

[Flags]
internal enum _flagsEnum : byte
{
    None = 0,           //00000000
    Option1 = 1,        //00000001
    Option2 = 1 << 1,   //00000010
    Option3 = 1 << 2,   //00000100
    Option4 = 1 << 3,   //00001000
    Option5 = 1 << 4,   //00010000
    Option6 = 1 << 5,   //00100000
    Option7 = 1 << 6,   //01000000
    Option8 = 1 << 7,   //10000000
    All = Byte.MaxValue,//11111111
}

_flagsEnum myFlagsEnum = _flagsEnum.None;

Is it faster to do..

bool hasFlag = myFlagsEnum.HasFlag(_flagsEnum.Option1);

or to do..

bool hasFlag = myFlagsEnum & _flagsEnum.Option1 != 0

If there's a performance difference between checking multiple flags, then take that into account as well.

Normally I'd check out the reference source, but in this case Enum.HasFlags just goes to an extern InternalHasFlags, so I have no idea what it's doing.

Answer 1

There is a performance cost to using HasFlag , because the implementation verifies that the enum value that you pass is of the same type as the flag.

With this difference out of the way, the implementation is highly optimized to avoid promoting shorter types, such as byte , to int :

switch (pMTThis->GetNumInstanceFieldBytes()) {
case 1:
    cmp = ((*(UINT8*)pThis & *(UINT8*)pFlags) == *(UINT8*)pFlags);
    break;
case 2:
    cmp = ((*(UINT16*)pThis & *(UINT16*)pFlags) == *(UINT16*)pFlags);
    break;
case 4:
    cmp = ((*(UINT32*)pThis & *(UINT32*)pFlags) == *(UINT32*)pFlags);
    break;
case 8:
    cmp = ((*(UINT64*)pThis & *(UINT64*)pFlags) == *(UINT64*)pFlags);
    break;
default:
    // should not reach here.
    UNREACHABLE_MSG("Incorrect Enum Type size!");
    break;
}

The source of ReflectionEnum::InternalHasFlag can be found here .

Although the cost is relatively high, it is unlikely to matter, except for the most extreme situations. I would recommend keeping it, unless your profiler points to this call as a largest bottleneck in your program.

Answer 2

Unsafe .

How about this? In my benchmarks ~25% much faster than HasFlag, ~10%-15% slower than bitwise, but generic.

Perhaps someone will be able to optimize that.

[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static unsafe Boolean HasFlags<T>(T* first, T* second) where T : unmanaged, Enum
{
    Byte* pf = (Byte*) first;
    Byte* ps = (Byte*) second;

    for (Int32 i = 0; i < sizeof(T); i++)
    {
        if ((pf[i] & ps[i]) != ps[i])
        {
                return false;
        }
    }

    return true;
}
    
/// <remarks>Faster analog of Enum.HasFlag</remarks>
/// <inheritdoc cref="Enum.HasFlag"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe Boolean HasFlags<T>(this T first, T second) where T : unmanaged, Enum
{
    return HasFlags(&first, &second);
}