Tipo Enum no C#

Um tipo de enumeração é um tipo de valor definido por um conjunto de constantes nomeadas do tipo numérico inteiro. Para definir um tipo de enumeração, usamos a palavra reservada enum e os nomes dos membros de enumeração. Podemos informar os valores de cada membro mas é opcional.

Nota: Não confundir com Enumerator.

C# suporta a noção de enumerações personalizadas pois ao construir um sistema, geralmente é conveniente criar um conjunto de nomes simbólicos que mapeiam para valores numéricos conhecidos. Por exemplo, se você estiver criando um sistema que tenha níveis de acesso a cada usuário, podemos usar o enum para definir estes níveis.

Aqui está uma enumeração chamada UserPermitions (você pode definir isso no mesmo arquivo que sua classe de programa, logo antes da definição da classe):

enum UserPermitions
{
    UserManager, // = 0
    GeneralManager, // = 1
    User, // = 2
    Admin, // = 3
    Director // = 4
}

A enumeração UserPermitions define cinco constantes nomeadas, correspondendo a valores numéricos discretos. Por padrão, o primeiro elemento é definido com o valor zero (n = 0), seguido por uma progressão n + 1. Você é livre para alterar o valor inicial conforme achar adequado.

Por exemplo, se fizesse sentido numerar os membros do UserPermitions como 302 a 306, você poderia fazê-lo da seguinte maneira:

    enum UserPermitions 
    {
        UserManager = 302 , // first index
        GeneralManager, // = 303
        User, // = 304
        Admin, // = 305 
        Director // = 306 
    }

As enumerações não precisam necessariamente seguir uma ordem sequencial e não precisam ter valores únicos.

enum UserPermitions
{
    UserManager = 302, // first index
    GeneralManager, // = 303
    User, // = 304
    Admin, // = 305 
    Director // = 306 
}

Por padrão o enum é um inteiro (System.int32), mas no C# é permitido alterar o tipo, para isso basta escrever a declaração da seguinte forma:

// This time, UserPermitions maps to an underlying byte.
// it will give an error is you try to set a value too big, like 999
enum UserPermitions : byte
{
    //code
}

Declaração de variáveis enum

Depois de estabelecer o intervalo e o tipo de armazenamento de sua enumeração, você pode usá-lo no lugar dos chamados números mágicos. Como as enumerações nada mais são do que um tipo de dados definido pelo usuário, você pode usá-las como valores de retorno de função, parâmetros de método, variáveis locais e assim por diante.

using System;
namespace EnumSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            var userPermitions = UserPermitions.GeneralManager;
            Console.WriteLine("User Permitions: " + userPermitions.ToString());
            Console.WriteLine("User Permitions: " + (int)userPermitions);
        }
    }

    enum UserPermitions
    {
        UserManager = 101, // first index
        GeneralManager, // = 102
        User, // = 200
        Admin, // = 1
        Director // = 2
    }
}

Observe que, ao atribuir um valor a uma variável enum, você deve definir o escopo do nome do enum (UserPermitions) para o valor (GeneralManager). Como as enumerações são um conjunto fixo de pares nome-valor, é ilegal definir uma variável enum com um valor que não seja definido diretamente pelo tipo enumerado.

var userPermitions = UserPermitions.Root;
// error CS0117: "UserPermitions" não contém uma definição para "Root"

Descobrir os pares de chave e valor de um enum

Enumerações tem suporte ao método ToString() que retorna o nome a string com o nome da enumeração atual. Este exemplo pode ser visto no programa completo acima.

Agora se está mais interessado no valor da chave, então basta fazer um cast para inteiro. Lembrando que o padrão é inteiro, então o cast deve ser feito para o valor que enum esta declarado.

O System.Enum também defini um método estático chamado GetValues(). Este método retorna um array. Cada item deste array corresponde a um dos membros do enumerador.

public static void PrintEnumerator(Enum myEnum)
{
    Array enumArr = Enum.GetValues(myEnum.GetType());

    for (int i = 0; i < enumArr.Length; i++)
    {
        Console.WriteLine($"Permission: {enumArr.GetValue(i)} - Id: {(int)enumArr.GetValue(i)} ");
    }
}
// This will exit
//Permission: UserManager - Id: 101
//Permission: GeneralManager - Id: 102
//Permission: User - Id: 103
//Permission: Admin - Id: 104
//Permission: Director - Id: 105

Para descobrir o tipo de armazenamento dos valores do enum podemos usar o método estático Enum.GetUnderlyingType(). Este método retorna o tipo usado no enumerador.

public static void GetEnumType(Enum myEnum)
{
    var enumType = Enum.GetUnderlyingType(myEnum.GetType());
    Console.WriteLine(enumType);
}
// This will exit
//System.Int32

Conclusão

As enumerações são usadas extensivamente em todas as bibliotecas de classes base do .NET. Por exemplo, ADO.NET faz uso de numerosas enumerações para representar o estado de uma conexão de banco de dados (por exemplo, aberta ou fechada) ou o estado de uma linha em um DataTable (por exemplo, alterado, novo ou desanexado).

Qualquer dúvida ou dicas, entre em contato: leandrolt@gmail.com

Principais referências

– Livro: Pro C# 7: With .NET and .NET Core – Andrew Troelsen
– https://docs.microsoft.com/pt-br/dotnet/api/system.enum.getunderlyingtype?view=net-5.0
– https://docs.microsoft.com/pt-br/dotnet/csharp/language-reference/builtin-types/enum
– https://docs.microsoft.com/pt-br/dotnet/api/system.enum?view=net-5.0

Leave a Reply

Your email address will not be published. Required fields are marked *