Converter Int em Enum em C#

Para converter um inteiro em um enum em C#, converta-o explicitamente para o tipo do enum: MyEnum value = (MyEnum)number;. Um enum é um tipo de valor com constantes nomeadas e um tipo integral subjacente. A conversão transforma o valor subjacente, mas não verifica se ele corresponde a uma constante declarada. Use Enum.IsDefined quando somente membros nomeados forem aceitos; use Enum.Parse ou Enum.TryParse quando a entrada estiver em formato de texto.

Converter um inteiro em enum com conversão explícita

A conversão explícita é a opção mais simples quando você já tem o inteiro e controla seu valor. Este exemplo completo define um enum cujo tipo subjacente padrão é int, converte o valor 2 e exibe o nome do membro correspondente. A saída mostra Two; o rótulo Converted Enum Value permanece em inglês no bloco imutável.

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

A conversão não valida o resultado. Por exemplo, converter 7 produz um valor de enum cujo valor subjacente é 7, embora MyEnum não declare nenhum membro com esse valor. Se a aplicação só puder aceitar membros declarados, verifique o valor com Enum.IsDefined antes de convertê-lo.

Analisar uma string que contém um inteiro com Enum.Parse

Enum.Parse recebe uma string. Quando um inteiro chega como texto, passe essa string ao método e converta o object retornado para o tipo de enum desejado. O exemplo analisa a string numérica "1". A saída mostra One; o rótulo Parsed Enum Value permanece em inglês no bloco imutável.

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

A análise de uma string numérica pode produzir um valor de enum cujo número subjacente não corresponde a nenhum membro declarado. Enum.Parse também lança uma exceção quando a entrada está malformada. Por isso, use Enum.TryParse quando quiser tratar uma falha comum de conversão sem controlar o fluxo por meio de exceções. O sucesso da análise, por si só, não verifica se o valor é um membro declarado.

Verificar se um valor de enum está declarado com Enum.IsDefined

Use Enum.IsDefined para determinar se um valor corresponde a uma constante de enum declarada. Este exemplo verifica um valor inteiro declarado e outro não declarado antes de convertê-los. Como MyEnum usa int como tipo subjacente padrão, os argumentos int em caixa correspondem ao tipo subjacente do enum. A saída informa que 2 corresponde a Two e que 7 não está declarado; os rótulos permanecem em inglês no bloco imutável.

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 verifica se o valor corresponde exatamente a uma constante declarada. É adequado para um enum simples com valores declarados separadamente. Em um enum [Flags], uma combinação válida de flags pode não estar declarada como constante própria; portanto, essa verificação pode rejeitar combinações que a aplicação pretende permitir.

Tentar analisar uma string que contém um inteiro com Enum.TryParse

Enum.TryParse retorna um booleano que indica se o texto pôde ser convertido para o tipo de enum e grava o valor analisado no parâmetro out. Se o dado disponível for um inteiro, converta-o para texto primeiro. O exemplo também verifica separadamente se o valor é um membro declarado, pois uma análise numérica bem-sucedida não confirma isso. A saída exibe One e indica que o valor está declarado; os rótulos Parsed e Declared permanecem em inglês no bloco imutável.

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.");
        }
    }
}

Para entradas com nomes, Enum.TryParse também aceita o nome de um membro declarado, como "Two". Um texto numérico pode ser analisado e resultar em um valor subjacente não declarado. Portanto, mantenha a verificação com Enum.IsDefined quando a aplicação exigir um membro declarado exato. Use a sobrecarga ignoreCase somente quando a correspondência de nomes sem distinção entre maiúsculas e minúsculas for apropriada.

Escolher o método de conversão adequado

Escolha o método conforme o formato da entrada e a validação necessária:

• Use uma conversão explícita para um inteiro em que você já confia e quando um valor de enum não declarado for aceitável.
• Use Enum.Parse para texto quando uma falha de análise deva ser tratada como exceção.
• Use Enum.TryParse para texto quando quiser um resultado booleano que indique o sucesso da conversão.
• Use Enum.IsDefined antes ou depois da conversão quando somente constantes de enum declaradas forem aceitáveis.

Nenhum dos métodos de análise garante que um valor numérico corresponda a uma constante declarada. Para entradas não confiáveis ou dinâmicas, tente analisá-las e depois verifique com Enum.IsDefined se a aplicação aceitar somente membros declarados. Para enums [Flags], defina e aplique regras próprias para validar as combinações permitidas, em vez de depender apenas de Enum.IsDefined.