HOWTO · Csharp

Convertir Int en Enum en C#

Aprende a convertir un entero en un enum de C# con una conversión (cast) o con análisis (parsing), y a comprobar si el resultado es un miembro declarado.

En esta página

Para convertir un entero en un enum en C#, conviértelo al tipo del enum: MyEnum value = (MyEnum)number;. Un enum es un tipo de valor con constantes con nombre y un tipo integral subyacente. La conversión transforma el valor subyacente, pero no comprueba si coincide con una constante declarada. Usa Enum.IsDefined si solo son válidos los miembros con nombre; usa Enum.Parse o Enum.TryParse cuando la entrada sea texto.

Convertir un entero en un enum mediante una conversión directa

Una conversión directa es la opción más sencilla cuando ya tienes el entero y controlas su valor. Este ejemplo completo define un enum cuyo tipo subyacente predeterminado es int, convierte el valor 2 e imprime el nombre del miembro correspondiente. La salida muestra «Converted Enum Value: Two»; la etiqueta se conserva en inglés porque el bloque de salida es inmutable.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int number = 2;
        MyEnum value = (MyEnum)number;
        Console.WriteLine($"Converted Enum Value: {value}");
    }
}

La conversión no valida el resultado. Por ejemplo, al convertir 7 se obtiene un valor enum cuyo valor subyacente es 7, aunque MyEnum no declare ningún miembro con ese valor. Si la aplicación solo debe aceptar miembros declarados, compruébalo con Enum.IsDefined antes de convertir.

Analizar una cadena con un entero mediante Enum.Parse

Enum.Parse recibe una cadena. Si el entero llega como texto, pasa esa cadena al método y convierte el object que devuelve al tipo enum de destino. El ejemplo analiza la cadena numérica "1" y muestra «Parsed Enum Value: One»; la etiqueta se conserva en inglés porque el bloque de salida es inmutable.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        string input = "1";
        MyEnum value = (MyEnum)Enum.Parse(typeof(MyEnum), input);
        Console.WriteLine($"Parsed Enum Value: {value}");
    }
}

El análisis de una cadena numérica puede producir un valor enum cuyo número subyacente no corresponda a ningún miembro declarado. Además, Enum.Parse señala las entradas mal formadas lanzando una excepción; por eso, usa Enum.TryParse cuando quieras gestionar los fallos habituales de conversión sin controlar el flujo mediante excepciones. Que el análisis tenga éxito no comprueba la pertenencia a los miembros declarados.

Comprobar si un valor enum está definido con Enum.IsDefined

Usa Enum.IsDefined para determinar si un valor corresponde a una constante enum declarada. Este ejemplo comprueba un valor entero declarado y otro no declarado antes de convertirlos. Como MyEnum usa int como tipo subyacente predeterminado, los argumentos int empaquetados coinciden con el tipo subyacente del enum. La salida muestra ambos resultados («2: defined as Two» y «7: not defined»); el texto se conserva en inglés porque el bloque de salida es inmutable.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int[] candidates = { 2, 7 };

        foreach (int number in candidates)
        {
            if (Enum.IsDefined(typeof(MyEnum), number))
            {
                MyEnum value = (MyEnum)number;
                Console.WriteLine($"{number}: defined as {value}");
            }
            else
            {
                Console.WriteLine($"{number}: not defined");
            }
        }
    }
}

Enum.IsDefined comprueba si existe una constante declarada con ese valor exacto. Es adecuado para un enum sencillo cuyos valores se declaran por separado. En un enum [Flags], una combinación válida de marcas puede no estar declarada explícitamente, por lo que esta comprobación podría rechazar combinaciones que la aplicación sí permite.

Analizar una cadena con un entero mediante Enum.TryParse

Enum.TryParse devuelve un booleano que indica si el texto se pudo convertir al tipo enum y escribe el valor analizado en su parámetro out. Si la entrada que tienes es un entero, conviértelo primero en texto. El ejemplo también comprueba la pertenencia por separado, ya que un análisis numérico correcto no demuestra que el número sea un miembro declarado. La salida muestra «Parsed: One» y «Declared: True»; las etiquetas se conservan en inglés porque el bloque de salida es inmutable.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int number = 1;
        string input = number.ToString();

        if (Enum.TryParse<MyEnum>(input, out MyEnum value))
        {
            Console.WriteLine($"Parsed: {value}");
            Console.WriteLine($"Declared: {Enum.IsDefined(typeof(MyEnum), value)}");
        }
        else
        {
            Console.WriteLine("Could not parse the input.");
        }
    }
}

Cuando el texto contiene un nombre, Enum.TryParse también acepta el nombre del miembro declarado, como "Two". El texto numérico puede convertirse en un valor subyacente no declarado; si la aplicación exige un miembro declarado exacto, mantén la comprobación con Enum.IsDefined. Usa la sobrecarga ignoreCase solo cuando sea apropiado comparar los nombres sin distinguir mayúsculas de minúsculas.

Elegir el método de conversión adecuado

Elige el método según el formato de la entrada y las comprobaciones que necesites:

  • Usa una conversión directa para un entero en cuyo valor ya confías y cuando sea aceptable obtener un valor enum no declarado.
  • Usa Enum.Parse con texto cuando quieras gestionar un análisis fallido mediante una excepción.
  • Usa Enum.TryParse con texto cuando necesites un resultado booleano que indique si la conversión tuvo éxito.
  • Usa Enum.IsDefined antes o después de la conversión cuando solo sean aceptables las constantes enum declaradas.

Ninguno de los métodos de análisis garantiza que un valor numérico corresponda a una constante declarada. Para entradas dinámicas o que no sean de confianza, intenta analizarlas y después comprueba Enum.IsDefined si la aplicación solo acepta miembros declarados. En los enums [Flags], define y aplica reglas de validación para las combinaciones permitidas en lugar de depender únicamente de Enum.IsDefined.