为什么通常用十六进制值定义标志枚举

很多时候，我看到使用十六进制值的标志枚举声明。例如：

[Flags]
public enum MyEnum
{
    None  = 0x0,
    Flag1 = 0x1,
    Flag2 = 0x2,
    Flag3 = 0x4,
    Flag4 = 0x8,
    Flag5 = 0x10
}

当我声明一个枚举时，通常会这样声明：

[Flags]
public enum MyEnum
{
    None  = 0,
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4,
    Flag4 = 8,
    Flag5 = 16
}

为什么有些人选择用十六进制而不是十进制写值，是否有原因或理由？从我的角度来看，使用十六进制值时很容易感到困惑，而意外地写成Flag5 = 0x16而不是Flag5 = 0x10。

原理可能有所不同，但我看到的一个优点是十六进制提醒您：“好吧，我们不再在人类创造的以10为基数的任意世界中处理数字。我们正在处理位-机器的世界-而我们将按照其规则行事。” 除非您正在处理数据存储布局很重要的相对较低级别的主题，否则很少使用十六进制。使用它暗示着事实，那就是我们现在所处的情况。

另外，我不确定C＃，但我知道在C中x << y是有效的编译时常量。使用位移似乎是最清楚的：

[Flags]
public enum MyEnum
{
    None  = 0,
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    Flag4 = 1 << 3,
    Flag5 = 1 << 4
}

可以很容易地看到它们是二进制标志。

None  = 0x0,  // == 00000
Flag1 = 0x1,  // == 00001
Flag2 = 0x2,  // == 00010
Flag3 = 0x4,  // == 00100
Flag4 = 0x8,  // == 01000
Flag5 = 0x10  // == 10000

尽管进展使它更加清晰：

Flag6 = 0x20  // == 00100000
Flag7 = 0x40  // == 01000000
Flag8 = 0x80  // == 10000000

我认为这只是因为序列始终为1,2,4,8，然后添加0。
如您所见：

0x1 = 1 
0x2 = 2
0x4 = 4
0x8 = 8
0x10 = 16
0x20 = 32
0x40 = 64
0x80 = 128
0x100 = 256
0x200 = 512
0x400 = 1024
0x800 = 2048

依此类推，只要您记住序列1-2-4-8，就可以构建所有后续标志，而不必记住2的幂

因为[Flags]意味着该枚举实际上是一个位域。有了[Flags]你可以使用按位AND（ &）和OR（ |）运营商的标志结合使用。在处理这样的二进制值时，几乎总是更清楚地使用十六进制值。这就是我们首先使用十六进制的原因。每个十六进制字符对应于恰好一个半字节（4位）。使用十进制时，此1到4映射不成立。

因为有一种机械的简单方法可以将十六进制的二乘幂加倍。用十进制表示，这很难。它需要长时间的繁衍。以十六进制表示，这是一个简单的更改。您可以一直执行此操作，直到1UL << 63十进制都无法执行。

因为对于人类来说，在标志中位更容易跟踪。每个十六进制数字都可以适合4位二进制数。

0x0 = 0000
0x1 = 0001
0x2 = 0010
0x3 = 0011

... and so on

0xF = 1111

通常，您不希望标志与位重叠，最简单的方法是使用十六进制值声明标志。

因此，如果您需要带有16位的标志，则将使用4位十六进制值，这样就可以避免错误的值：

0x0001 //= 1 = 000000000000 0001
0x0002 //= 2 = 000000000000 0010
0x0004 //= 4 = 000000000000 0100
0x0008 //= 8 = 000000000000 1000
...
0x0010 //= 16 = 0000 0000 0001 0000
0x0020 //= 32 = 0000 0000 0010 0000
...
0x8000 //= 32768 = 1000 0000 0000 0000