Trasmetti Int a Enum generico in C #

Simile a Cast int per enumerare in C # ma il mio enum è un parametro di tipo generico. Qual è il modo migliore per gestirlo?

Esempio:

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

Genera un errore del compilatore Cannot convert type 'int' to 'T'

Il codice completo è il seguente, dove value può contenere int o null.

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

Il modo più semplice che ho trovato è forzare la mano del compilatore aggiungendo un cast a object.

return (T)(object)i.Value;

Dovresti essere in grado di utilizzare Enum.Parseper questo:

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

Questo articolo parla dell'analisi di enumerazioni generiche per i metodi di estensione:

• Analisi Enum generica con metodi di estensione

Ecco una soluzione molto veloce che abusa del fatto che il runtime crea più istanze di classi generiche statiche. Scatena i tuoi demoni dell'ottimizzazione interiore!

Questo brilla davvero quando stai leggendo Enums da uno stream in modo generico. Combina con una classe esterna che memorizza anche nella cache il tipo sottostante dell'enumerazione e un BitConverter per scatenare il fantastico.

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

Risultati su Core i7-3740QM con ottimizzazioni abilitate:

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

In alternativa, se riesci a ottenere un'enumerazione non come tipo generico, ma come Tipo, usa semplicemente

Enum.ToObject

https://msdn.microsoft.com/en-us/library/system.enum.toobject(v=vs.110).aspx

In .NET core è ora possibile utilizzare il codice System.Runtime.CompilerServices.Unsafe come questo:

return Unsafe.As<int, TEnum>(ref int32);

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