Cast Int para Enumerar genérico en C#

Question

Similar a Cast int to enum in C# pero mi enum es un parámetro de tipo genérico. ¿Cuál es la mejor forma de manejarlo?

Ejemplo:

private T ConvertEnum<T>(int i) where T : struct, IConvertible 
{ 
    return (T)i; 
} 

genera error compilador Cannot convert type 'int' to 'T'

código completa es como sigue, donde el valor puede contener el int, o nulo.

private int? TryParseInt(string value) 
{ 
    var i = 0; 
    if (!int.TryParse(value, out i)) 
    { 
     return null; 
    } 
    return i; 
} 

private T? TryParseEnum<T>(string value) where T : struct, IConvertible 
{ 
    var i = TryParseInt(value); 
    if (!i.HasValue) 
    { 
     return null; 
    } 

    return (T)i.Value; 
} 

Answer 1

La forma más sencilla que he encontrado es para forzar la mano del compilador mediante la adición de un yeso para object.

return (T)(object)i.Value; 

Answer 2

Usted debe ser capaz de utilizar Enum.Parse para esto:

return (T)Enum.Parse(typeof(T), i.Value.ToString(), true); 

Este artículo habla de analizar las enumeraciones genéricas de métodos extenstion:

• Generic Enum Parsing with Extension Methods

Answer 3

He aquí una solución muy rápida que abusa del hecho que el tiempo de ejecución crea múltiples instancias de clases genéricas estáticas. ¡Desata tus demonios de optimización interna!

Esto realmente brilla cuando estás leyendo Enums de una secuencia de una manera genérica. Combínelo con una clase externa que también almacena en caché el tipo subyacente de la enumeración y un BitConverter para liberar lo increíble.

void Main() 
{ 
    Console.WriteLine("Cast (reference): {0}", (TestEnum)5); 
    Console.WriteLine("EnumConverter: {0}", EnumConverter<TestEnum>.Convert(5)); 
    Console.WriteLine("Enum.ToObject: {0}", Enum.ToObject(typeof(TestEnum), 5)); 

    int iterations = 1000 * 1000 * 100; 
    Measure(iterations, "Cast (reference)",() => { var t = (TestEnum)5; }); 
    Measure(iterations, "EnumConverter",() => EnumConverter<TestEnum>.Convert(5)); 
    Measure(iterations, "Enum.ToObject",() => Enum.ToObject(typeof(TestEnum), 5)); 
} 

static class EnumConverter<TEnum> where TEnum : struct, IConvertible 
{ 
    public static readonly Func<long, TEnum> Convert = GenerateConverter(); 

    static Func<long, TEnum> GenerateConverter() 
    { 
     var parameter = Expression.Parameter(typeof(long)); 
     var dynamicMethod = Expression.Lambda<Func<long, TEnum>>(
      Expression.Convert(parameter, typeof(TEnum)), 
      parameter); 
     return dynamicMethod.Compile(); 
    } 
} 

enum TestEnum 
{ 
    Value = 5 
} 

static void Measure(int repetitions, string what, Action action) 
{ 
    action(); 

    var total = Stopwatch.StartNew(); 
    for (int i = 0; i < repetitions; i++) 
    { 
     action(); 
    } 
    Console.WriteLine("{0}: {1}", what, total.Elapsed); 
} 

Resultados de Core i7-3740QM con optimizaciones habilitadas:

Cast (reference): Value 
EnumConverter: Value 
Enum.ToObject: Value 
Cast (reference): 00:00:00.3175615 
EnumConverter: 00:00:00.4335949 
Enum.ToObject: 00:00:14.3396366 

Answer 4

public static class Extensions 
    { 
     public static T ToEnum<T>(this int param) 
     { 
      var info = typeof(T); 
      if (info.IsEnum) 
      { 
       T result = (T)Enum.Parse(typeof(T), param.ToString(), true); 
       return result; 
      } 

      return default(T); 
     } 
    }