¿Cómo convertir de System.Enum a un entero base?

Me gustaría crear un método genérico para convertir cualquier tipo derivado de System.Enum a su valor entero correspondiente, sin conversión y preferiblemente sin analizar una cadena.

Por ejemplo, lo que quiero es algo como esto:

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

Pero esto no parece funcionar. Resharper informa que no puede convertir una expresión de tipo 'System.Enum' a escribir 'int'.

Ahora se me ocurrió esta solución, pero prefiero tener algo más eficiente.

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

¿Alguna sugerencia?

Si no quieres emitir,

Convert.ToInt32()

podría hacer el truco.

La transmisión directa (vía (int)enumValue) no es posible. Tenga en cuenta que esto también sería "peligroso", ya que una enumeración puede tener diferentes tipos subyacentes ( int, long,byte ...).

Más formalmente: System.Enumno tiene una relación de herencia directa con Int32(aunque ambos son ValueTypes), por lo que la conversión explícita no puede ser correcta dentro del sistema de tipos

Lo hice funcionar lanzando a un objeto y luego a un int:

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

Esta es fea y probablemente no sea la mejor manera. Seguiré jugando con eso, para ver si puedo encontrar algo mejor ...

EDITAR: Estaba a punto de publicar que Convert.ToInt32 (enumValue) también funciona, y noté que MartinStettner se me adelantó.

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

Prueba:

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

EDITAR 2: En los comentarios, alguien dijo que esto solo funciona en C # 3.0. Acabo de probar esto en VS2005 así y funcionó:

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

Si necesita convertir cualquier enumeración a su tipo subyacente (no todas las enumeraciones están respaldadas por int), puede usar:

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

¿Por qué necesitas reinventar la rueda con un método auxiliar? Es perfectamente legal asignar un enumvalor a su tipo subyacente.

Es menos mecanografiado y, en mi opinión, más legible de usar ...

int x = (int)DayOfWeek.Tuesday;

... en lugar de algo como ...

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

De mi respuesta aquí :

Dado ecomo en:

Enum e = Question.Role;

Entonces estos funcionan:

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

Los dos últimos son feos. El primero debería ser más legible, aunque el segundo es mucho más rápido. O puede ser que un método de extensión sea lo mejor, lo mejor de ambos 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;
}

Ahora puedes llamar:

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

Transmitir de una System.Enuma una intfunciona bien para mí (también está en MSDN ). Quizás sea un error de Resharper.

Dado que las enumeraciones están restringidas a byte, sbyte, short, ushort, int, uint, long y ulong, podemos hacer algunas suposiciones.

Podemos evitar excepciones durante la conversión utilizando el contenedor más grande disponible. Desafortunadamente, no está claro qué contenedor usar porque ulong aumentará para números negativos y long aumentará para números entre long.MaxValue y ulong.MaxValue. Necesitamos cambiar entre estas opciones según el tipo subyacente.

Por supuesto, aún debe decidir qué hacer cuando el resultado no encaja dentro de un int. Creo que el casting está bien, pero todavía hay algunos errores:

1. para enumeraciones basadas en un tipo con un espacio de campo mayor que int (long y ulong), es posible que algunas enumeraciones evalúen el mismo valor.
2. emitir un número mayor que int.MaxValue arrojará una excepción si se encuentra en una región marcada.

Aquí está mi sugerencia, dejaré que el lector decida dónde exponer esta función; como ayudante o extensión.

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

No olvide que el tipo Enum en sí tiene un montón de funciones auxiliares estáticas. Si todo lo que quiere hacer es convertir una instancia de la enumeración a su tipo entero correspondiente, entonces la conversión es probablemente la forma más eficiente.

Creo que ReSharper se queja porque Enum no es una enumeración de ningún tipo en particular, y las enumeraciones en sí se derivan de un tipo de valor escalar, no de Enum. Si necesita una conversión adaptable de una manera genérica, diría que esto podría adaptarse bien a usted (tenga en cuenta que el tipo de enumeración en sí también se incluye en el genérico:

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

Esto podría usarse así:

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

// ...

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

No puedo decirlo con certeza, pero el código anterior incluso podría ser compatible con la inferencia de tipo de C #, lo que permite lo siguiente:

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