按位(标志)enum指南

老了，但想试着做个小抄，即使是供我自己参考:

例子

[Flags]
enum E {
    A = 0b1,
    B = 0b10,
    C = 0b100
}

E e = E.A;        // Assign (e = A)
e |= E.B | E.C;   // Add    (e = A, B, C)
e &= ~E.A & ~E.B; // Remove (e = C) -- alt syntax: &= ~(E.A | E.B)
e ^= E.A | E.C;   // Toggle (e = A)
e.HasFlag(E.A);   // Test   (returns true)

// Testing multiple flags using bit operations:
bool hasAandB = ( e & (E.A | E.B) ) == (E.A | E.B);

好处:定义一个Flags enum

通常，我们像这样使用整数:

[Flags]
enum E {
    A = 1,
    B = 2,
    C = 4,
    // etc.

但当我们接近更大的数字时，计算下一个值就不那么容易了:

  // ...
  W = 4194304,
  X = 8388608,
  // ..

然而，有两个替代方案:二进制和十六进制字面量。

对于二进制，只需在前一个值的末尾追加一个0:

[Flags]
enum E {
    A = 0b1,
    B = 0b10,
    C = 0b100,
    // ...
    W = 0b100_0000_0000_0000_0000_0000,
    X = 0b1000_0000_0000_0000_0000_0000,

十六进制也有一个方便的模式，可能看起来不那么丑陋:循环1、2、4、8，在每次完整迭代后加一个0。

[Flags]
enum E {
    A = 0x1,
    B = 0x2,
    C = 0x4,
    D = 0x8,
    E = 0x10, // 16
    F = 0x20, // 32, etc.
    // ...
    W = 0x400000,
    X = 0x800000,

. net的内置标志枚举操作非常有限。大多数情况下，用户需要弄清楚按位操作的逻辑。

在。net 4中，HasFlag方法被添加到Enum中，这有助于简化用户的代码，但不幸的是，它存在许多问题。

HasFlag不是类型安全的，因为它接受任何类型的枚举值参数，而不仅仅是给定的枚举类型。 HasFlag对于是否检查值是否具有enum value参数提供的所有或任何标志具有歧义性。顺便说一下。 HasFlag相当慢，因为它需要装箱，这会导致分配和更多的垃圾收集。

由于. net对标志枚举的支持有限，我编写了OSS库enums。NET解决了这些问题，使处理标志枚举更加容易。

下面是它提供的一些操作以及仅使用. net框架的等效实现。

把国旗

.NET标志| otherFlags

Enums.NET 标志。CombineFlags（otherFlags）

---

删除标志

.NET标志& ~otherFlags

Enums.NET 标志。删除标志（其他标志）

---

常见的旗帜

.NET标志和其他标志

Enums.NET 标志。CommonFlags（otherFlags）

---

切换的旗帜

.NET flags ^ otherFlags

Enums.NET 标志。切换标志（其他标志）

---

拥有所有旗帜

.NET (flags & otherFlags) == otherFlags或flags. hasflag (otherFlags)

Enums.NET 标志。HasAllFlags（otherFlags）

---

是否有旗帜

.NET (flags & otherFlags) != 0

Enums.NET 标志。HasAnyFlags（otherFlags）

---

让国旗

.NET

Enumerable.Range(0, 64)
  .Where(bit => ((flags.GetTypeCode() == TypeCode.UInt64 ? (long)(ulong)flags : Convert.ToInt64(flags)) & (1L << bit)) != 0)
  .Select(bit => Enum.ToObject(flags.GetType(), 1L << bit))`

Enums.NET 标志。GetFlags（）

---

我正试图将这些改进整合到。net Core中，并最终整合到完整的。net框架中。你可以在这里查看我的提案。

@Drew

注意，除了在最简单的情况下，Enum。与手动编写代码相比，HasFlag会带来严重的性能损失。考虑下面的代码:

[Flags]
public enum TestFlags
{
    One = 1,
    Two = 2,
    Three = 4,
    Four = 8,
    Five = 16,
    Six = 32,
    Seven = 64,
    Eight = 128,
    Nine = 256,
    Ten = 512
}


class Program
{
    static void Main(string[] args)
    {
        TestFlags f = TestFlags.Five; /* or any other enum */
        bool result = false;

        Stopwatch s = Stopwatch.StartNew();
        for (int i = 0; i < 10000000; i++)
        {
            result |= f.HasFlag(TestFlags.Three);
        }
        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds); // *4793 ms*

        s.Restart();
        for (int i = 0; i < 10000000; i++)
        {
            result |= (f & TestFlags.Three) != 0;
        }
        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds); // *27 ms*        

        Console.ReadLine();
    }
}

在1000万次迭代中，HasFlags扩展方法花费了4793毫秒，而标准的逐位实现只需要27毫秒。

为了获得最佳性能和零垃圾，请使用以下代码:

using System;
using T = MyNamespace.MyFlags;

namespace MyNamespace
{
    [Flags]
    public enum MyFlags
    {
        None = 0,
        Flag1 = 1,
        Flag2 = 2
    }

    static class MyFlagsEx
    {
        public static bool Has(this T type, T value)
        {
            return (type & value) == value;
        }

        public static bool Is(this T type, T value)
        {
            return type == value;
        }

        public static T Add(this T type, T value)
        {
            return type | value;
        }

        public static T Remove(this T type, T value)
        {
            return type & ~value;
        }
    }
}

习惯用法是使用按位或等于操作符来设置位:

flags |= 0x04;

为了澄清一点，这个习语是按位使用，并带否定:

flags &= ~0x04;

有时你有一个偏移量来标识你的位，然后习惯用法是将这些偏移量与左移结合使用:

flags |= 1 << offset;
flags &= ~(1 << offset);

在。net 4中，你现在可以这样写:

flags.HasFlag(FlagsEnum.Bit4)