Como converter de System.Enum para um inteiro de base?

Eu gostaria de criar um método genérico para converter qualquer tipo derivado de System.Enum em seu valor inteiro correspondente, sem converter e, de preferência, sem analisar uma string.

Por exemplo, o que eu quero é algo assim:

// Trivial example, not actually what I'm doing.
class Converter
{
    int ToInteger(System.Enum anEnum)
    {
        (int)anEnum;
    }
}

Mas isso não parece funcionar. Resharper relata que você não pode converter uma expressão do tipo 'System.Enum' para o tipo 'int'.

Agora eu vim com essa solução, mas prefiro algo mais eficiente.

class Converter
{
    int ToInteger(System.Enum anEnum)
    {
        return int.Parse(anEnum.ToString("d"));
    }
}

Alguma sugestão?

Se você não quiser lançar,

Convert.ToInt32()

poderia fazer o truque.

O cast direto (via (int)enumValue) não é possível. Note-se que isso também seria "perigoso", já que uma enumeração pode ter diferentes tipos subjacentes ( int, long, byte...).

Mais formalmente: System.Enumnão tem relação de herança direta com Int32(embora ambos sejam ValueTypes), então a conversão explícita não pode ser correta dentro do sistema de tipo

Comecei a trabalhar lançando para um objeto e depois para um int:

public static class EnumExtensions
{
    public static int ToInt(this Enum enumValue)
    {
        return (int)((object)enumValue);
    }
}

Isso é feio e provavelmente não é a melhor maneira. Vou continuar mexendo nisso, para ver se consigo encontrar algo melhor ...

EDIT: Estava prestes a postar que Convert.ToInt32 (enumValue) funciona bem, e percebi que MartinStettner chegou antes de mim.

public static class EnumExtensions
{
    public static int ToInt(this Enum enumValue)
    {
        return Convert.ToInt32(enumValue);
    }
}

Teste:

int x = DayOfWeek.Friday.ToInt();
Console.WriteLine(x); // results in 5 which is int value of Friday

EDIT 2: Nos comentários, alguém disse que isso só funciona em C # 3.0. Acabei de testar isso no VS2005 assim e funcionou:

public static class Helpers
{
    public static int ToInt(Enum enumValue)
    {
        return Convert.ToInt32(enumValue);
    }
}

    static void Main(string[] args)
    {
        Console.WriteLine(Helpers.ToInt(DayOfWeek.Friday));
    }

Se precisar converter qualquer enum em seu tipo subjacente (nem todos os enums são apoiados por int), você pode usar:

return System.Convert.ChangeType(
    enumValue,
    Enum.GetUnderlyingType(enumValue.GetType()));

Por que você precisa reinventar a roda com um método auxiliar? É perfeitamente legal lançar um enumvalor para seu tipo subjacente.

É menos digitação e na minha opinião mais legível para usar ...

int x = (int)DayOfWeek.Tuesday;

... em vez de algo como ...

int y = Converter.ToInteger(DayOfWeek.Tuesday);
// or
int z = DayOfWeek.Tuesday.ToInteger();

Da minha resposta aqui :

Dado ecomo em:

Enum e = Question.Role;

Então estes funcionam:

int i = Convert.ToInt32(e);
int i = (int)(object)e;
int i = (int)Enum.Parse(e.GetType(), e.ToString());
int i = (int)Enum.ToObject(e.GetType(), e);

Os dois últimos são completamente feios. O primeiro deve ser mais legível, embora o segundo seja muito mais rápido. Ou pode ser que um método de extensão seja o melhor, o melhor dos dois mundos.

public static int GetIntValue(this Enum e)
{
    return e.GetValue<int>();
}

public static T GetValue<T>(this Enum e) where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T>
{
    return (T)(object)e;
}

Agora você pode ligar para:

e.GetValue<int>(); //or
e.GetIntValue();

Transmitir de um System.Enumpara um intfunciona bem para mim (também está no MSDN ). Talvez seja um bug do Resharper.

Como os Enums são restritos a byte, sbyte, short, ushort, int, uint, long e ulong, podemos fazer algumas suposições.

Podemos evitar exceções durante a conversão usando o maior contêiner disponível. Infelizmente, qual recipiente usar não está claro porque ulong explodirá para números negativos e long irá explodir para números entre long.MaxValue e ulong.MaxValue. Precisamos alternar entre essas opções com base no tipo subjacente.

Claro, você ainda precisa decidir o que fazer quando o resultado não couber dentro de um int. Acho que o elenco está bem, mas ainda existem algumas pegadinhas:

1. para enums com base em um tipo com um espaço de campo maior que int (long e ulong), é possível que alguns enums sejam avaliados com o mesmo valor.
2. lançar um número maior que int.MaxValue lançará uma exceção se você estiver em uma região marcada.

Aqui está minha sugestão, vou deixar para o leitor decidir onde expor esta função; como ajudante ou extensão.

public int ToInt(Enum e)
{
  unchecked
  {
    if (e.GetTypeCode() == TypeCode.UInt64)
      return (int)Convert.ToUInt64(e);
    else
      return (int)Convert.ToInt64(e);
  }
}

Não se esqueça de que o próprio tipo Enum contém várias funções auxiliares estáticas. Se tudo o que você deseja fazer é converter uma instância do enum em seu tipo inteiro correspondente, a conversão é provavelmente a maneira mais eficiente.

Acho que ReSharper está reclamando porque Enum não é uma enumeração de nenhum tipo específico, e as próprias enumerações derivam de um tipo de valor escalar, não Enum. Se você precisar de elenco adaptável de uma forma genérica, eu diria que isso pode servir para você (observe que o próprio tipo de enumeração também está incluído no genérico:

public static EnumHelpers
{
    public static T Convert<T, E>(E enumValue)
    {
        return (T)enumValue;
    }
}

Isso poderia então ser usado da seguinte forma:

public enum StopLight: int
{
    Red = 1,
    Yellow = 2,
    Green = 3
}

// ...

int myStoplightColor = EnumHelpers.Convert<int, StopLight>(StopLight.Red);

Não posso dizer com certeza de cara, mas o código acima pode até ser compatível com a inferência de tipo do C #, permitindo o seguinte:

int myStoplightColor = EnumHelpers.Convert<int>(StopLight.Red);