Bagaimana cara mengonversi dari System.Enum ke basis integer?

Saya ingin membuat metode umum untuk mengonversi tipe turunan System.Enum apa pun ke nilai integer yang sesuai, tanpa casting dan sebaiknya tanpa parsing string.

Misalnya, yang saya inginkan adalah seperti ini:

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

Tapi ini sepertinya tidak berhasil. Resharper melaporkan bahwa Anda tidak dapat menggunakan ekspresi tipe 'System.Enum' untuk mengetik 'int'.

Sekarang saya telah menemukan solusi ini tetapi saya lebih memilih sesuatu yang lebih efisien.

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

Ada saran?

Jika Anda tidak ingin melakukan cast,

Convert.ToInt32()

bisa melakukan triknya.

Pemeran langsung (melalui (int)enumValue) tidak dimungkinkan. Catatan bahwa ini juga akan menjadi "berbahaya" karena enum dapat memiliki jenis yang mendasari yang berbeda ( int, long, byte...).

Secara lebih formal: System.Enumtidak memiliki hubungan pewarisan langsung dengan Int32(meskipun keduanya adalah ValueType), jadi pemeran eksplisit tidak dapat benar dalam sistem tipe

Saya membuatnya bekerja dengan mentransmisikan ke objek dan kemudian ke int:

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

Ini jelek dan mungkin bukan cara terbaik. Saya akan terus mengotak-atiknya, untuk melihat apakah saya bisa menghasilkan sesuatu yang lebih baik ....

EDIT: Baru saja akan memposting bahwa Convert.ToInt32 (enumValue) berfungsi juga, dan perhatikan bahwa MartinStettner mengalahkan saya untuk itu.

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

Uji:

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

EDIT 2: Di komentar, seseorang mengatakan bahwa ini hanya berfungsi di C # 3.0. Saya baru saja menguji ini di VS2005 seperti ini dan berhasil:

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

Jika Anda perlu mengonversi enum apa pun ke tipe dasarnya (tidak semua enum didukung oleh int), Anda dapat menggunakan:

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

Mengapa Anda perlu menemukan kembali roda dengan metode helper? Sangat legal untuk memberikan enumnilai pada tipe dasarnya.

Ini kurang mengetik, dan menurut saya lebih mudah dibaca, menggunakan ...

int x = (int)DayOfWeek.Tuesday;

... daripada sesuatu seperti ...

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

Dari jawaban saya di sini :

Diberikan eseperti pada:

Enum e = Question.Role;

Kemudian pekerjaan ini:

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

Dua yang terakhir sangat jelek. Yang pertama harus lebih mudah dibaca, meskipun yang kedua lebih cepat. Atau mungkin metode penyuluhan adalah yang terbaik, terbaik dari kedua dunia.

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

Sekarang Anda dapat menghubungi:

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

Mentransmisi dari a System.Enumke an intberfungsi dengan baik untuk saya (juga ada di MSDN ). Mungkin itu bug Resharper.

Karena Enum dibatasi untuk byte, sbyte, short, ushort, int, uint, long dan ulong, kita dapat membuat beberapa asumsi.

Kami dapat menghindari pengecualian selama konversi dengan menggunakan wadah terbesar yang tersedia. Sayangnya, wadah mana yang akan digunakan tidak jelas karena ulong akan meledak untuk angka negatif dan panjang akan meledak untuk angka antara long.MaxValue dan ulong.MaxValue. Kita perlu beralih di antara pilihan ini berdasarkan jenis yang mendasarinya.

Tentu saja, Anda masih perlu memutuskan apa yang harus dilakukan jika hasilnya tidak sesuai dengan int. Saya pikir casting tidak apa-apa, tetapi masih ada beberapa kekurangan:

1. untuk enum berdasarkan tipe dengan ruang bidang lebih besar dari int (panjang dan ulong), beberapa enum mungkin akan dievaluasi ke nilai yang sama.
2. mentransmisikan angka yang lebih besar dari int.MaxValue akan memunculkan pengecualian jika Anda berada di wilayah yang dicentang.

Inilah saran saya, saya akan menyerahkannya kepada pembaca untuk memutuskan di mana akan mengekspos fungsi ini; sebagai pembantu atau perpanjangan tangan.

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

Jangan lupa bahwa tipe Enum itu sendiri memiliki banyak fungsi pembantu statis di dalamnya. Jika semua yang ingin Anda lakukan adalah mengonversi instance enum ke jenis bilangan bulat yang sesuai, maka transmisi mungkin adalah cara yang paling efisien.

Saya pikir ReSharper mengeluh karena Enum bukanlah pencacahan jenis tertentu, dan pencacahan itu sendiri berasal dari jenis penilaian skalar, bukan Enum. Jika Anda memerlukan casting yang dapat disesuaikan dengan cara yang umum, saya akan mengatakan ini dapat menyesuaikan Anda dengan baik (perhatikan bahwa jenis enumerasi itu sendiri juga termasuk dalam generik:

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

Ini kemudian dapat digunakan seperti ini:

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

// ...

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

Saya tidak bisa mengatakan dengan pasti dari atas kepala saya, tetapi kode di atas bahkan mungkin didukung oleh inferensi tipe C #, memungkinkan yang berikut:

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