Entendendo as flags do C#

Tim Corey

8m 32s

Os flags em C# são um recurso poderoso, porém frequentemente negligenciado, que permite aos desenvolvedores gerenciar permissões e opções usando operações bit a bit. Em seu vídeo " Binário em C#: Flags em 10 minutos ou menos ", Tim Corey oferece uma explicação clara e concisa de como as flags funcionam e como podem ser utilizadas de forma eficaz em C#. Neste artigo, analisaremos as explicações e os insights de Tim apresentados no vídeo para obter uma melhor compreensão dos Flags em C#.

O que são bandeiras?

Tim começa por apresentar o conceito de bandeiras. Ele explica que os Flags permitem atribuir múltiplos valores a uma única variável, tornando-os úteis para gerenciar permissões em um aplicativo. Para ilustrar isso, Tim cria um enum chamado SystemPermissions que inclui várias permissões como SQL, WebServer, Redis, Azure, GitHub e BuildSystem.

Tim destaca que, sem Flags, uma única variável pode conter apenas uma permissão por vez. Por exemplo, se tentarmos atribuir SystemPermissions.GitHub a um usuário, não podemos também atribuir SystemPermissions.BuildSystem a menos que usemos um array, o que se torna complicado de gerenciar.

O problema sem bandeiras

Neste ponto, Tim demonstra as limitações das atribuições de enumeração tradicionais. Se atribuirmos permissões uma de cada vez, verificá-las posteriormente exigirá iterar por uma matriz, o que é ineficiente e não escalável. Isso leva a uma implementação "feia", como Tim descreve, onde gerenciar múltiplas permissões se torna um transtorno.

Apresentando o atributo Flags

Para resolver esse problema, Tim introduz o atributo [Flags], que permite que um enum seja tratado como um campo de bits. Ele explica que a cada permissão é atribuído um valor binário único através de deslocamento bit a bit.

Em vez de atribuir números incrementais (0, 1, 2, 3, etc.), Tim atribui valores usando potências de dois:

[Flags]
enum SystemPermissions
{
    None = 0,
    SQL = 1 << 0,       // 00000001
    WebServer = 1 << 1, // 00000010
    Redis = 1 << 2,     // 00000100
    Azure = 1 << 3,     // 00001000
    GitHub = 1 << 4,    // 00010000
    BuildSystem = 1 << 5 // 00100000
}

[Flags]
enum SystemPermissions
{
    None = 0,
    SQL = 1 << 0,       // 00000001
    WebServer = 1 << 1, // 00000010
    Redis = 1 << 2,     // 00000100
    Azure = 1 << 3,     // 00001000
    GitHub = 1 << 4,    // 00010000
    BuildSystem = 1 << 5 // 00100000
}

<Flags>
Enum SystemPermissions
    None = 0
    SQL = 1 << 0       ' 00000001
    WebServer = 1 << 1 ' 00000010
    Redis = 1 << 2     ' 00000100
    Azure = 1 << 3     ' 00001000
    GitHub = 1 << 4    ' 00010000
    BuildSystem = 1 << 5 ' 00100000
End Enum

<Flags>
Enum SystemPermissions
    None = 0
    SQL = 1 << 0       ' 00000001
    WebServer = 1 << 1 ' 00000010
    Redis = 1 << 2     ' 00000100
    Azure = 1 << 3     ' 00001000
    GitHub = 1 << 4    ' 00010000
    BuildSystem = 1 << 5 ' 00100000
End Enum

Tim explica que deslocar os bits garante que cada permissão tenha um valor único, sem sobreposição, permitindo a combinação eficiente de múltiplas permissões.

Atribuição e combinação de sinalizadores

Tim demonstra então como atribuir e combinar permissões usando operações bit a bit. Ele explica que podemos atribuir várias permissões a um usuário usando o operador OR bit a bit (|operador ):

SystemPermissions timsPermissions = SystemPermissions.SQL | SystemPermissions.Redis | SystemPermissions.GitHub;

SystemPermissions timsPermissions = SystemPermissions.SQL | SystemPermissions.Redis | SystemPermissions.GitHub;

Dim timsPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis Or SystemPermissions.GitHub

Dim timsPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis Or SystemPermissions.GitHub

Isso atribui as permissões de SQL, Redis e GitHub a timsPermissions, armazenando-as em uma única variável usando operações bit a bit.

Verificando permissões com sinalizadores

Um dos principais benefícios de Flags é a capacidade de verificar se uma permissão específica está definida usando o operador AND bit a bit (&). Tim demonstra como verificar se um usuário possui uma permissão específica:

if ((timsPermissions & SystemPermissions.SQL) == SystemPermissions.SQL)
{
    Console.WriteLine("Tim has SQL access.");
}

if ((timsPermissions & SystemPermissions.SQL) == SystemPermissions.SQL)
{
    Console.WriteLine("Tim has SQL access.");
}

If (timsPermissions And SystemPermissions.SQL) = SystemPermissions.SQL Then
    Console.WriteLine("Tim has SQL access.")
End If

If (timsPermissions And SystemPermissions.SQL) = SystemPermissions.SQL Then
    Console.WriteLine("Tim has SQL access.")
End If

Tim enfatiza que essa abordagem é muito mais eficiente do que percorrer um array em loop, pois permite comparações bit a bit rápidas.

Remover permissões

Tim também aborda como remover uma permissão usando o operador AND e NOT bit a bit (~). Se precisarmos revogar a permissão SQL de timsPermissions, fazemos assim:

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions = timsPermissions And Not SystemPermissions.SQL

timsPermissions = timsPermissions And Not SystemPermissions.SQL

Isso remove efetivamente a permissão SQL, mantendo as demais permissões intactas.

Exibição de flags em binário

Para visualizar como os Flags funcionam, Tim sugere converter o valor do enum em sua representação binária. Ele usa um método auxiliar para exibir o valor binário de uma permissão:

Console.WriteLine(Convert.ToString((int)timsPermissions, 2));

Console.WriteLine(Convert.ToString((int)timsPermissions, 2));

Console.WriteLine(Convert.ToString(CInt(timsPermissions), 2))

Console.WriteLine(Convert.ToString(CInt(timsPermissions), 2))

Tim explica que isso ajuda a entender como os bits individuais são definidos e manipulados dentro da enumeração.

Por que usar sinalizadores?

Tim conclui enfatizando por que os Flags são úteis em C#:

• Permitem armazenar múltiplos valores em uma única variável.
• Permitem uma gestão eficiente de permissões.
• Elas simplificam a verificação e a modificação de permissões usando operações bit a bit.

Ele também destaca que os Flags são comumente usados ​​em cenários como permissões de arquivos, funções de usuário e configurações de aplicativos.

Considerações finais

Ao longo do vídeo, Tim Corey fornece uma demonstração clara e prática de como funcionam os Flags em C#. Usando o atributo [Flags] e operações bit a bit, podemos gerenciar eficientemente múltiplas permissões sem precisar de estruturas de dados complexas. Se você trabalha com permissões ou configurações que exigem vários valores, os Flags são uma excelente ferramenta para simplificar sua implementação.

Para um entendimento prático, confira o vídeo de Tim Corey, onde ele explica esses conceitos passo a passo. Flags podem parecer complicadas no início, mas, uma vez compreendida sua natureza binária, elas se tornam um recurso incrivelmente útil no desenvolvimento em C#.