¿Qué es una enumeración en C#?

Una enumeración (o enum) es un tipo de dato por valor que permite definir un conjunto de constantes simbólicas con nombre. En lugar de trabajar con números “mágicos” o cadenas sueltas, las enumeraciones aportan:

• Legibilidad: el código es más fácil de leer y mantener.
• Seguridad de tipos: el compilador impide usar valores fuera del rango permitido.
• Autocompletado: los IDEs muestran la lista de opciones disponibles.

Firma básica

enum <Nombre> : <tipo subyacente> { Miembro1 = valor1, Miembro2 = valor2, … }

El tipo subyacente puede ser byte, sbyte, short, ushort, int (por defecto), uint, long o ulong.

Declaración y uso fundamental

// Declaración
public enum EstadoPedido
{
    Pendiente,        // 0
    Procesando,       // 1
    Enviado,          // 2
    Entregado,        // 3
    Cancelado         // 4
}

// Uso
EstadoPedido estado = EstadoPedido.Procesando;

if (estado == EstadoPedido.Enviado)
{
    Console.WriteLine("Tu paquete está en camino 🚚");
}

Puntos clave

1. Valores predeterminados
   Si no asignas un número, el primero es 0 y cada siguiente se incrementa en 1.
2. Conversión a entero int codigo = (int)EstadoPedido.Enviado; // 2
3. Conversión desde entero EstadoPedido e = (EstadoPedido)3; // Entregado

Enumeraciones con valores personalizados

Asignar valores explícitos resulta útil cuando:

• Debes mapear un enum a un código externo (p. ej., base de datos).
• Quieres que los valores empiecen por 1 (o cualquier otro número).

public enum RolUsuario : byte
{
    Invitado  = 1,
    Miembro   = 2,
    Admin     = 3,
    SuperAdmin= 4
}

Enumeraciones Flags (bit a bit)

Cuando una variable puede almacenar varios estados simultáneamente, se emplea Flags y potencias de dos:

[Flags]
public enum PermisosArchivo
{
    Ninguno   = 0,
    Leer      = 1 << 0,  // 1
    Escribir  = 1 << 1,  // 2
    Ejecutar  = 1 << 2,  // 4
    // Combinaciones comunes
    LecturaEscritura = Leer | Escribir // 3
}

// Uso
PermisosArchivo permisos = PermisosArchivo.Leer | PermisosArchivo.Ejecutar;

bool puedeLeer = permisos.HasFlag(PermisosArchivo.Leer);          // true
bool puedeEscribir = permisos.HasFlag(PermisosArchivo.Escribir);   // false

Buenas prácticas con Flags

• Incluye siempre Ninguno = 0.
• Usa [Flags] para que ToString() devuelva combinaciones legibles ("Leer, Ejecutar").
• Asegúrate de que cada miembro simple sea una potencia de dos.

Representación como texto

EstadoPedido estado = EstadoPedido.Enviado;
string texto = estado.ToString();           // "Enviado"

Si necesitas deserializar:

EstadoPedido estado = Enum.Parse<EstadoPedido>("Procesando");
// o bien seguro:
bool ok = Enum.TryParse("Procesando", out EstadoPedido resultado);

Iterar sobre los miembros

foreach (EstadoPedido e in Enum.GetValues<EstadoPedido>())
{
    Console.WriteLine($"{(int)e} - {e}");
}

Buenas prácticas generales

Errores comunes

1. Olvidar el sufijo Enum.Parse<EnumTipo>()
   Llamar a Enum.Parse sin tipo genérico devuelve object y hay que castear.
2. No validar enteros externos
   Convertir un número inválido provoca valores no definidos. Usa Enum.IsDefined() o TryParse.
3. Comparar contra números mágicos
   Evita if (estado == 2); siempre compara con EstadoPedido.Enviado.

Conclusión

Las enumeraciones en C# son una herramienta sencilla y potente para dar significado a valores numéricos, aumentar la legibilidad y prevenir errores de lógica. Dominar su sintaxis y variantes —incluidos los enums de flags— te permitirá escribir código más claro, mantenible y seguro. ¡Empieza a reemplazar esos números mágicos por enums y notarás la diferencia enseguida!