Làm thế nào để chuyển đổi từ System.Enum sang số nguyên cơ sở?

Tôi muốn tạo một phương thức chung để chuyển đổi bất kỳ kiểu dẫn xuất System.Enum nào thành giá trị số nguyên tương ứng của nó mà không cần ép kiểu và tốt nhất là không phân tích cú pháp chuỗi.

Ví dụ, những gì tôi muốn là một cái gì đó như thế này:

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

Nhưng điều này dường như không hoạt động. Resharper báo cáo rằng bạn không thể truyền biểu thức kiểu 'System.Enum' thành kiểu 'int'.

Bây giờ tôi đã nghĩ ra giải pháp này nhưng tôi muốn có một cái gì đó hiệu quả hơn.

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

Bất kỳ đề xuất?

Nếu bạn không muốn truyền,

Convert.ToInt32()

có thể làm các thủ thuật.

Truyền trực tiếp (qua (int)enumValue) là không thể. Lưu ý rằng điều này cũng sẽ là "nguy hiểm" vì một enum có thể có các loại cơ bản khác nhau ( int, long, byte...).

Chính thức hơn: System.Enumkhông có mối quan hệ kế thừa trực tiếp với Int32(mặc dù cả hai đều là ValueTypes), do đó, kết xuất rõ ràng không thể đúng trong hệ thống kiểu

Tôi đã làm cho nó hoạt động bằng cách truyền đến một đối tượng và sau đó đến một int:

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

Đây là cách xấu xí và có lẽ không phải là cách tốt nhất. Tôi sẽ tiếp tục làm điều đó, để xem liệu tôi có thể nghĩ ra một cái gì đó tốt hơn ...

CHỈNH SỬA: Tôi vừa chuẩn bị đăng rằng Convert.ToInt32 (enumValue) cũng hoạt động, và nhận thấy rằng MartinStettner đã đánh bại tôi về nó.

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

Kiểm tra:

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

CHỈNH SỬA 2: Trong các nhận xét, ai đó nói rằng điều này chỉ hoạt động trong C # 3.0. Tôi vừa thử nghiệm điều này trong VS2005 như thế này và nó hoạt động:

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

Nếu bạn cần chuyển đổi bất kỳ enum nào thành kiểu cơ bản của nó (không phải tất cả các enum đều được hỗ trợ bởi int) thì bạn có thể sử dụng:

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

Tại sao bạn cần phải phát minh lại bánh xe bằng phương pháp trợ giúp? Hoàn toàn hợp pháp khi truyền một enumgiá trị cho loại cơ bản của nó.

Nó ít gõ hơn, và theo ý kiến ​​của tôi là dễ đọc hơn, để sử dụng ...

int x = (int)DayOfWeek.Tuesday;

... hơn là những thứ như ...

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

Từ câu trả lời của tôi ở đây :

Như etrong:

Enum e = Question.Role;

Sau đó, những công việc này:

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

Hai cái cuối cùng là xấu xí. Cái đầu tiên sẽ dễ đọc hơn, mặc dù cái thứ hai nhanh hơn nhiều. Hoặc có thể là một phương pháp mở rộng là tốt nhất, tốt nhất của cả hai thế giới.

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

Bây giờ bạn có thể gọi:

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

Truyền từ a System.Enumđến một inthoạt động tốt đối với tôi (nó cũng trên MSDN ). Có lẽ đó là một lỗi Resharper.

Vì Enums bị giới hạn ở byte, sbyte, short, ushort, int, uint, long và ulong, chúng ta có thể đưa ra một số giả định.

Chúng tôi có thể tránh ngoại lệ trong quá trình chuyển đổi bằng cách sử dụng vùng chứa lớn nhất hiện có. Thật không may, hộp chứa nào sẽ được sử dụng không rõ ràng vì ulong sẽ phát nổ đối với các số âm và dài sẽ phát nổ đối với các số giữa long.MaxValue và ulong.MaxValue. Chúng ta cần chuyển đổi giữa các lựa chọn này dựa trên loại cơ bản.

Tất nhiên, bạn vẫn cần quyết định phải làm gì khi kết quả không nằm trong một int. Tôi nghĩ việc casting là ổn, nhưng vẫn còn một số vấn đề:

1. đối với enum dựa trên kiểu có không gian trường lớn hơn int (dài và dài), có thể một số enum sẽ đánh giá cùng một giá trị.
2. ép kiểu một số lớn hơn int.MaxValue sẽ ném ra một ngoại lệ nếu bạn đang ở trong một vùng được kiểm tra.

Đây là gợi ý của tôi, tôi sẽ để người đọc quyết định nơi để hiển thị chức năng này; như một người trợ giúp hoặc một phần mở rộng.

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

Đừng quên rằng bản thân kiểu Enum có một loạt các hàm trợ giúp tĩnh trong đó. Nếu tất cả những gì bạn muốn làm là chuyển đổi một thể hiện của enum thành kiểu số nguyên tương ứng của nó, thì ép kiểu có lẽ là cách hiệu quả nhất.

Tôi nghĩ rằng ReSharper đang phàn nàn vì Enum không phải là một kiểu liệt kê của bất kỳ kiểu cụ thể nào, và bản thân các phép liệt kê bắt nguồn từ một kiểu giá trị vô hướng, không phải Enum. Nếu bạn cần truyền kiểu thích ứng theo một cách chung chung, tôi sẽ nói điều này có thể phù hợp với bạn (lưu ý rằng bản thân kiểu liệt kê cũng được bao gồm trong kiểu chung:

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

Điều này sau đó có thể được sử dụng như vậy:

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

// ...

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

Tôi không thể nói chắc chắn được, nhưng đoạn mã trên thậm chí có thể được hỗ trợ bởi kiểu suy luận của C #, cho phép những điều sau:

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