C # में जेनेरिक एनम के लिए कास्ट इंट

Question 1

C # में Enum करने के लिए Cast int के समान लेकिन मेरा Enum एक जेनेरिक टाइप पैरामीटर है। इससे निपटने का सबसे अच्छा तरीका क्या है ?

उदाहरण:

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

कंपाइलर त्रुटि उत्पन्न करता है Cannot convert type 'int' to 'T'

पूर्ण कोड निम्नानुसार है, जहां मूल्य में इंट, या अशक्त हो सकते हैं।

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

Question 2

मैंने जो सबसे सरल तरीका पाया है वह है कि एक कास्ट को जोड़कर संकलक के हाथ को मजबूर करना object।

return (T)(object)i.Value;

Question 3

आपको इसके लिए उपयोग करने में सक्षम होना चाहिए Enum.Parse:

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

इस लेख में विलुप्त होने के तरीकों के लिए सामान्य ज्ञान को शामिल करने की बात की गई है:

एक्सटेंशन विधियों के साथ सामान्य एनम पार्सिंग

Question 4

यहां एक बहुत तेज़ समाधान है जो इस तथ्य का दुरुपयोग करता है कि रनटाइम स्थिर सामान्य वर्गों के कई उदाहरण बनाता है। अपने आंतरिक अनुकूलन राक्षसों को दिलाने!

यह वास्तव में चमकता है जब आप एनम को सामान्य शैली में एक धारा से पढ़ रहे हैं। एक बाहरी वर्ग के साथ गठबंधन करें जो कमाल करने के लिए Enum के अंतर्निहित प्रकार और BitConverter को कैश करता है।

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

कोर i7-3740QM पर परिणाम अनुकूलन के साथ सक्षम:

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

Question 5

वैकल्पिक रूप से, यदि आप एक सामान्य प्रकार के रूप में नहीं, बल्कि टाइप के रूप में एनम प्राप्त कर सकते हैं, तो बस उपयोग करें

Enum.ToObject

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

Question 6

.NET कोर में अब System.Runtime.CompilerServices.Unsafe कोड का उपयोग करना संभव है :

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

Question 7

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