Compartilhar via

Enumerações em C#

Dica

Novo no desenvolvimento de software? Comece primeiro com os tutoriais de Introdução . Você encontrará enumerações depois de precisar representar um conjunto fixo de opções em seu código.

Experimentou em outro idioma? As enumerações C# funcionam de forma semelhante a enumerações em Java ou C++, com suporte adicional para sinalizadores de bits e correspondência de padrões. Analise as seções de sinalizadores e expressão switch para identificar padrões específicos do C#.

Um tipo de enumeração (ou enumeração) define um conjunto de constantes nomeadas apoiadas por um valor inteiro. Use enumes quando um valor deve ser um de um conjunto fixo de opções — dias da semana, códigos de status HTTP, níveis de log ou direções. As enumerações tornam seu código mais legível e menos propenso a erros do que as constantes de inteiro bruto porque o compilador impõe os valores nomeados.

Declarar uma enumeração

Defina uma enumeração com a enum palavra-chave seguida pelo nome do tipo e seus membros:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Por padrão, o tipo subjacente é int, e os valores começam em 0 e incrementam em um. Season.Spring é 0, Season.Summer é 1, e assim por diante.

Especificar um tipo subjacente e valores explícitos

Você pode escolher um tipo integral diferente e atribuir valores explícitos para controlar a representação numérica:

enum HttpStatus : ushort
{
    OK = 200,
    NotFound = 404,
    InternalServerError = 500
}

Use valores explícitos quando os números tiverem significado externo, como códigos de status HTTP ou identificadores de protocolo. O tipo subjacente pode ser qualquer tipo integral, exceto char. Use byte, short, ushort, , int, uint, long, ou ulong.

Usar enumerações em expressões de comutador

As enumerações funcionam naturalmente com switch expressões e correspondência de padrões. O compilador avisa se você não lida com todos os membros, o que ajuda a evitar bugs quando você adiciona um novo valor mais tarde:

static string DescribeSeason(Season season) => season switch
{
    Season.Spring => "Flowers bloom and temperatures rise.",
    Season.Summer => "Long days and warm weather.",
    Season.Autumn => "Leaves change color and fall.",
    Season.Winter => "Short days and cold temperatures.",
    _ => throw new ArgumentOutOfRangeException(nameof(season))
};

var today = Season.Autumn;
Console.WriteLine(DescribeSeason(today));

O padrão de descarte (_) manipula qualquer valor não explicitamente listado. A correspondência de padrões é um recurso C# que testa um valor em relação a uma forma ou condição. Neste exemplo, cada case verifica se a enumeração corresponde a um membro específico. As expressões switch são uma das várias formas de correspondência de padrões. Para obter mais informações sobre correspondência de padrões, consulte Correspondência de padrões.

Sinalizadores de bits

Quando uma enumeração representa uma combinação de opções em vez de uma única opção, defina cada membro como um poder de dois e aplique :FlagsAttribute

[Flags]
enum FileAccess
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4,
    ReadWrite = Read | Write,
    All = Read | Write | Execute
}

Combine valores usando o | operador e teste para sinalizadores individuais usando HasFlag:

var permissions = FileAccess.Read | FileAccess.Write;

Console.WriteLine(permissions);                          // ReadWrite
Console.WriteLine(permissions.HasFlag(FileAccess.Read)); // True
Console.WriteLine(permissions.HasFlag(FileAccess.Execute)); // False

O [Flags] atributo também afeta ToString(). Ele exibe valores combinados como nomes separados por vírgulas (como Read, Write) em vez de um número bruto. Para obter mais informações, consulte System.FlagsAttribute.

Converter entre enums e inteiros

Conversões explícitas transformam uma enumeração em seu tipo inteiro subjacente.

var status = HttpStatus.NotFound;
ushort code = (ushort)status;
Console.WriteLine($"Status: {status} ({code})"); // Status: NotFound (404)

var fromCode = (HttpStatus)200;
Console.WriteLine(fromCode); // OK

Lembre-se de que a conversão de um inteiro em uma enumeração não valida se o valor corresponde a um membro definido. Use Enum.IsDefined para verificar a validade ao aceitar a entrada numérica de fontes externas.

Analisar cadeias de caracteres e iterar valores

A Enum classe base fornece métodos para analisar strings e iterar sobre todos os valores definidos:

// Parse a string to an enum value:
var parsed = Enum.Parse<Season>("Winter");
Console.WriteLine(parsed); // Winter

// Try to parse safely. It returns false only when the input can't be parsed. Call Enum.IsDefined to validate named members:
if (Enum.TryParse<Season>("Monsoon", out var unknown))
{
    Console.WriteLine(unknown);
}
else
{
    Console.WriteLine("'Monsoon' is not a valid Season"); // 'Monsoon' is not a valid Season
}

// Iterate over all values in an enum:
foreach (var season in Enum.GetValues<Season>())
{
    Console.WriteLine($"{season} = {(int)season}");
}
// Spring = 0
// Summer = 1
// Autumn = 2
// Winter = 3

Use Enum.TryParse<TEnum>(String, Boolean, TEnum) em vez de Enum.Parse<TEnum>(String) quando a entrada pode ser inválida. Ele retorna false em vez de gerar uma exceção.

Consulte também

  • Last updated on