Por que as enumerações de flag geralmente são definidas com valores hexadecimais

Muitas vezes, vejo declarações de flag enum que usam valores hexadecimais. Por exemplo:

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

Quando declaro uma enumeração, geralmente a declaro assim:

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

Existe uma razão ou razão para que algumas pessoas escolham escrever o valor em hexadecimal em vez de decimal? Na minha opinião, é mais fácil ficar confuso ao usar valores hexadecimais e escrever acidentalmente em Flag5 = 0x16vez de Flag5 = 0x10.

As razões podem diferir, mas uma vantagem que vejo é que o hexadecimal lembra: "Ok, não estamos mais lidando com números no mundo arbitrário e inventado pelo homem da base dez. Estamos lidando com bits - o mundo da máquina - e nós vai jogar de acordo com suas regras. " O hexadecimal raramente é usado, a menos que você esteja lidando com tópicos de nível relativamente baixo, onde o layout da memória dos dados é importante. Usá-lo sugere que essa é a situação em que estamos agora.

Além disso, não tenho certeza sobre C #, mas sei que em C x << yé uma constante válida em tempo de compilação. Usar deslocamento de bits parece o mais claro:

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

Torna fácil ver que esses são sinalizadores binários .

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

Embora a progressão torne ainda mais claro:

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

Eu acho que é só porque a sequência é sempre 1,2,4,8 e depois adiciona um 0.
Como você pode 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

e assim por diante, desde que você se lembre da sequência 1-2-4-8, poderá criar todas as sinalizações subseqüentes sem precisar se lembrar dos poderes de 2

Porque [Flags]significa que o enum é realmente um campo de bits . Com [Flags]você, você pode usar os operadores AND ( &) e OR ( |) bit a bit para combinar os sinalizadores. Ao lidar com valores binários como esse, é quase sempre mais claro usar valores hexadecimais. Esta é a razão pela qual usamos hexadecimal em primeiro lugar. Cada caractere hexadecimal corresponde a exatamente uma mordidela (quatro bits). Com decimal, esse mapeamento de 1 para 4 não é verdadeiro.

Porque existe uma maneira mecânica e simples de dobrar uma potência de dois em hexadecimal. Em decimal, isso é difícil. Requer longa multiplicação em sua cabeça. Em hexadecimal, é uma mudança simples. Você pode fazer isso até o máximo 1UL << 63que não puder fazer em decimal.

Porque é mais fácil seguir para humanos onde os bits estão na bandeira. Cada dígito hexadecimal pode caber em um binário de 4 bits.

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

... and so on

0xF = 1111

Normalmente, você deseja que seus sinalizadores não se sobreponham aos bits, a maneira mais fácil de visualizá-lo e usando valores hexadecimais para declarar seus sinalizadores.

Portanto, se você precisar de sinalizadores com 16 bits, usará valores hexadecimais de 4 dígitos e poderá evitar valores errados:

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