¿Por qué las enumeraciones de marca suelen definirse con valores hexadecimales

Muchas veces veo declaraciones de enumeración de bandera que usan valores hexadecimales. Por ejemplo:

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

Cuando declaro una enumeración, generalmente la declaro así:

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

¿Hay alguna razón o razón por la cual algunas personas eligen escribir el valor en hexadecimal en lugar de decimal? A mi modo de ver, es más fácil confundirse cuando se utilizan valores hexadecimales y escribir accidentalmente en Flag5 = 0x16lugar de Flag5 = 0x10.

Los fundamentos pueden diferir, pero una ventaja que veo es que el hexadecimal te recuerda: "Está bien, ya no estamos tratando con números en el arbitrario mundo inventado por los humanos de la base diez. Estamos tratando con bits, el mundo de la máquina, y nosotros vamos a jugar según sus reglas ". El hexadecimal rara vez se usa a menos que se trate de temas de nivel relativamente bajo donde el diseño de memoria de los datos es importante. Usarlo sugiere el hecho de que esa es la situación en la que estamos ahora.

Además, no estoy seguro acerca de C #, pero sé que en C x << yhay una constante de tiempo de compilación válida. Usar cambios de bit parece lo más claro:

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

Hace que sea fácil ver que estos son indicadores binarios .

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

Aunque la progresión lo hace aún más claro:

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

Creo que es solo porque la secuencia siempre es 1,2,4,8 y luego agrego un 0.
Como puede ver:

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

y así sucesivamente, siempre que recuerde la secuencia 1-2-4-8, puede construir todas las banderas posteriores sin tener que recordar los poderes de 2

Porque [Flags]significa que la enumeración es realmente un campo de bits . Con [Flags]usted puede usar los operadores bit a bit AND ( &) y OR ( |) para combinar las banderas. Cuando se trata con valores binarios como este, casi siempre es más claro usar valores hexadecimales. Esta es la razón por la que usamos hexadecimal en primer lugar. Cada carácter hexadecimal corresponde exactamente a un mordisco (cuatro bits). Con decimal, esta asignación de 1 a 4 no es verdadera.

Porque hay una forma mecánica y simple de duplicar una potencia de dos en hex. En decimal, esto es difícil. Requiere una larga multiplicación en tu cabeza. En hexadecimal es un cambio simple. Puede llevar a cabo esto hasta el punto 1UL << 63que no puede hacer en decimal.

Porque es más fácil de seguir para los humanos donde están los bits en la bandera. Cada dígito hexadecimal puede caber en un binario de 4 bits.

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

... and so on

0xF = 1111

Por lo general, desea que sus banderas no se superpongan bits, la forma más fácil de hacerlo y visualizarlo es utilizando valores hexadecimales para declarar sus banderas.

Entonces, si necesita banderas con 16 bits, usará valores hexadecimales de 4 dígitos y de esa manera puede evitar valores erróneos:

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