Truyền vào Enum Chung trong C #

Tương tự như Cast int to enum trong C # nhưng enum của tôi là một tham số Generic Type. Là gì tốt nhất cách để xử lý này?

Thí dụ:

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

Tạo lỗi trình biên dịch Cannot convert type 'int' to 'T'

Mã đầy đủ như sau, trong đó giá trị có thể chứa int hoặc 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;
}

Cách đơn giản nhất mà tôi đã tìm thấy là buộc bàn tay của trình biên dịch bằng cách thêm một diễn viên vào object.

return (T)(object)i.Value;

Bạn sẽ có thể sử dụng Enum.Parsecho việc này:

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

Bài viết này nói về phân tích cú pháp các enum chung cho các phương thức mở rộng:

• Phân tích cú pháp Enum chung với các phương thức mở rộng

Đây là một giải pháp rất nhanh lạm dụng thực tế là thời gian chạy tạo ra nhiều trường hợp của các lớp chung tĩnh. Giải phóng những con quỷ tối ưu hóa bên trong của bạn!

Điều này thực sự tỏa sáng khi bạn đang đọc Enums từ một luồng theo kiểu chung chung. Kết hợp với một lớp bên ngoài cũng lưu trữ loại cơ bản của enum và một BitConverter để giải phóng điều tuyệt vời.

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

Kết quả trên Core i7-3740QM với tối ưu hóa được bật:

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

Ngoài ra, nếu bạn có thể nhận được một enum không phải là một kiểu chung chung, mà là Kiểu, thì chỉ cần sử dụng

Enum.ToObject

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

Trong lõi .NET bây giờ có thể sử dụng mã System.Runtime.CompilerServices.Unsafe như sau:

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