Partilhar via

Enumerações em C#

Sugestão

Novo no desenvolvimento de software? Começa primeiro pelos tutoriais para começar . Vais encontrar enums quando precisares de representar um conjunto fixo de escolhas no teu código.

Experiente noutra língua? Os enums em C# funcionam de forma semelhante aos enums em Java ou C++, com suporte adicional para flags de bits e correspondência de padrões. Passe os olhos nas flags e nas secções de expressão switch para padrões específicos de C#.

Um tipo de enumeração (ou enum) define um conjunto de constantes nomeadas suportadas por um valor inteiro. Use enums quando um valor deve ser uma das opções fixas — dias da semana, códigos de estado HTTP, níveis de registo ou direções. Os enums tornam o seu código mais legível e menos propenso a erros do que constantes inteiras brutas porque o compilador impõe os valores nomeados.

Declare um enum

Defina um enum com a enum palavra-chave seguida do nome do tipo e dos seus membros:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Por defeito, o tipo subjacente é int, e os valores começam em 0 e incrementam em um. Season.Spring é 0, Season.Summer é 1, e assim sucessivamente.

Especifique um tipo subjacente e valores explícitos

Pode escolher um tipo de 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 têm significado externo, como códigos de estado 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 enums em expressões de comutação

Os enums funcionam naturalmente com switch expressões e correspondência de padrões. O compilador avisa-o se não gerir todos os membros, o que ajuda a prevenir erros quando 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 (_) trata qualquer valor não explicitamente listado. A correspondência de padrões é uma característica C# que testa um valor contra uma forma ou condição. Neste exemplo, cada um case verifica se o enum corresponde a um membro específico. As expressões de switch são uma das várias formas de correspondência de padrões. Para mais informações sobre correspondência de padrões, consulte Correspondência de padrões.

Bandeiras de bits

Quando um enum representa uma combinação de escolhas em vez de uma única escolha, defina cada membro como uma potência de dois e aplique a FlagsAttribute:

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

Combinar valores usando o | operador e testar as bandeiras 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 atributo [Flags] também afeta ToString(). Apresenta valores combinados como nomes separados por vírgulas (como Read, Write) em vez de um número bruto. Para obter mais informações, veja System.FlagsAttribute.

Converter entre enums e inteiros

Casts explícitos convertem entre um enum e o 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

Tenha em atenção que converter um inteiro para um enum não valida se o valor corresponde a um membro definido. Use Enum.IsDefined para verificar a validade quando aceita entrada numérica de fontes externas.

Analisar cadeias e iterar valores

A Enum classe base fornece métodos para analisar cadeias 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 não ser válida. Ele retorna false em vez de lançar uma exceção.

Consulte também

  • Last updated on