Compartir vía

Enumeraciones de C#

Sugerencia

¿No está familiarizado con el desarrollo de software? Comience primero con los tutoriales de introducción . Encontrará enumeraciones una vez que necesite representar un conjunto fijo de opciones en el código.

¿Competente en otro idioma? Las enumeraciones de C# funcionan de forma similar a las enumeraciones de Java o C++, con compatibilidad adicional con marcas de bits y coincidencia de patrones. Desplázate por las banderas y las expresiones switch en busca de patrones específicos de C#.

Un tipo de enumeración (o enumeración) define un conjunto de constantes con nombre respaldadas por un valor entero. Use enumeraciones cuando un valor debe ser uno de un conjunto fijo de opciones: días de la semana, códigos de estado HTTP, niveles de registro o instrucciones. Las enumeraciones hacen que el código sea más legible y menos propenso a errores que las constantes enteras sin procesar porque el compilador aplica los valores nominados.

Declarar una enumeración

Defina una enumeración con la enum palabra clave seguida del nombre de tipo y sus miembros:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

De forma predeterminada, el tipo subyacente es int, y los valores comienzan en 0 e incrementan en uno. Season.Spring es 0, Season.Summer es 1, y así sucesivamente.

Especificar un tipo subyacente y valores explícitos

Puede elegir un tipo entero diferente y asignar valores explícitos para controlar la representación numérica:

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

Use valores explícitos cuando los números tengan significado externo, como códigos de estado HTTP o identificadores de protocolo. El tipo subyacente puede ser cualquier tipo entero excepto char. Use byte, short, ushort, int, uint, longo ulong.

Uso de enumeraciones en expresiones switch

Las enumeraciones funcionan de forma natural con expresiones switch y con la coincidencia de patrones. El compilador le advierte si no controla todos los miembros, lo que ayuda a evitar errores al agregar un nuevo valor más adelante:

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));

El patrón de descarte (_) controla cualquier valor que no aparezca explícitamente. La coincidencia de patrones es una característica de C# que prueba un valor con una forma o condición. En este ejemplo, cada uno case comprueba si la enumeración coincide con un miembro específico. Las expresiones switch son una de varias formas de coincidencia de patrones. Para obtener más información sobre la coincidencia de patrones, consulte Coincidencia de patrones.

Indicadores de bits

Cuando una enumeración representa una combinación de opciones en lugar de una sola opción, defina cada miembro como una potencia de dos y aplique :FlagsAttribute

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

Combine valores mediante el | operador y pruebe las marcas individuales mediante 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

El [Flags] atributo también afecta a ToString(). Muestra valores combinados como nombres separados por comas (como Read, Write) en lugar de un número sin formato. Para obtener más información, consulte System.FlagsAttribute.

Conversión entre enumeraciones e enteros

Las conversiones explícitas convierten entre una enumeración y su tipo entero subyacente:

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

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

Tenga en cuenta que la conversión de un entero a una enumeración no valida si el valor coincide con un miembro definido. Use Enum.IsDefined para comprobar la validez al aceptar la entrada numérica de orígenes externos.

Análisis de cadenas e iteración de valores

La Enum clase base proporciona métodos para analizar cadenas e iterar en todos los 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) en lugar de Enum.Parse<TEnum>(String) cuando la entrada podría no ser válida. Devuelve false en lugar de producir una excepción.

Consulte también

  • Last updated on