Dapatkan nilai int dari enum dalam C #

Saya memiliki kelas yang disebut Questions(jamak). Di kelas ini ada enum yang disebut Question(tunggal) yang terlihat seperti ini.

public enum Question
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

Di Questionskelas saya memiliki get(int foo)fungsi yang mengembalikan Questionsobjek untuk itu foo. Apakah ada cara mudah untuk mendapatkan nilai integer dari enum sehingga saya bisa melakukan sesuatu seperti ini Questions.Get(Question.Role)?

Cukup masukkan enum, mis

int something = (int) Question.Role;

Hal di atas akan berfungsi untuk sebagian besar enum yang Anda lihat di alam liar, seperti tipe yang mendasari standar untuk enum int.

Namun, seperti yang ditunjukkan cecilphillip , enum dapat memiliki tipe yang berbeda. Jika enum dinyatakan sebagai uint, long, atau ulong, harus dilemparkan dengan jenis enum; misalnya untuk

enum StarsInMilkyWay:long {Sun = 1, V645Centauri = 2 .. Wolf424B = 2147483649};

kamu harus menggunakan

long something = (long)StarsInMilkyWay.Wolf424B;

Sejak Enum dapat menjadi semua jenis terpisahkan ( byte, int, short, dll), cara yang lebih kuat untuk mendapatkan nilai integral yang mendasari enum akan memanfaatkan GetTypeCodemetode dalam hubungannya dengan Convertkelas:

enum Sides {
    Left, Right, Top, Bottom
}
Sides side = Sides.Bottom;

object val = Convert.ChangeType(side, side.GetTypeCode());
Console.WriteLine(val);

Ini harus bekerja terlepas dari tipe integral yang mendasarinya.

Deklarasikan sebagai kelas statis yang memiliki konstanta publik:

public static class Question
{
    public const int Role = 2;
    public const int ProjectFunding = 3;
    public const int TotalEmployee = 4;
    public const int NumberOfServers = 5;
    public const int TopBusinessConcern = 6;
}

Dan kemudian Anda dapat referensi sebagai Question.Role, dan selalu mengevaluasi ke intatau apa pun yang Anda definisikan sebagai.

Question question = Question.Role;
int value = (int) question;

Akan menghasilkan value == 2.

Pada catatan terkait, jika Anda ingin mendapatkan intnilai dari System.Enum, maka diberikan di esini:

Enum e = Question.Role;

Kamu bisa menggunakan:

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 benar-benar jelek. Saya lebih suka yang pertama.

Ini lebih mudah daripada yang Anda pikirkan - enum sudah merupakan int. Itu hanya perlu diingatkan:

int y = (int)Question.Role;
Console.WriteLine(y); // Prints 2

Contoh:

public Enum EmpNo
{
    Raj = 1,
    Rahul,
    Priyanka
}

Dan dalam kode di belakang untuk mendapatkan nilai enum:

int setempNo = (int)EmpNo.Raj; // This will give setempNo = 1

atau

int setempNo = (int)EmpNo.Rahul; // This will give setempNo = 2

Enum akan bertambah 1, dan Anda dapat mengatur nilai awal. Jika Anda tidak menetapkan nilai awal, nilai awalnya akan ditetapkan sebagai 0.

Saya baru-baru ini dikonversi dari menggunakan enum dalam kode saya yang mendukung daripada menggunakan kelas dengan konstruktor yang dilindungi dan instance statis yang telah ditentukan (terima kasih kepada Roelof - C # Pastikan Nilai Valum Enum yang Valid - Metode Futureproof ).

Sehubungan dengan itu, berikut ini bagaimana saya sekarang mendekati masalah ini (termasuk konversi implisit ke / dari int).

public class Question
{
    // Attributes
    protected int index;
    protected string name;
    // Go with a dictionary to enforce unique index
    //protected static readonly ICollection<Question> values = new Collection<Question>();
    protected static readonly IDictionary<int,Question> values = new Dictionary<int,Question>();

    // Define the "enum" values
    public static readonly Question Role = new Question(2,"Role");
    public static readonly Question ProjectFunding = new Question(3, "Project Funding");
    public static readonly Question TotalEmployee = new Question(4, "Total Employee");
    public static readonly Question NumberOfServers = new Question(5, "Number of Servers");
    public static readonly Question TopBusinessConcern = new Question(6, "Top Business Concern");

    // Constructors
    protected Question(int index, string name)
    {
        this.index = index;
        this.name = name;
        values.Add(index, this);
    }

    // Easy int conversion
    public static implicit operator int(Question question) =>
        question.index; //nb: if question is null this will return a null pointer exception

    public static implicit operator Question(int index) =>        
        values.TryGetValue(index, out var question) ? question : null;

    // Easy string conversion (also update ToString for the same effect)
    public override string ToString() =>
        this.name;

    public static implicit operator string(Question question) =>
        question?.ToString();

    public static implicit operator Question(string name) =>
        name == null ? null : values.Values.FirstOrDefault(item => name.Equals(item.name, StringComparison.CurrentCultureIgnoreCase));


    // If you specifically want a Get(int x) function (though not required given the implicit converstion)
    public Question Get(int foo) =>
        foo; //(implicit conversion will take care of the conversion for you)
}

Keuntungan dari pendekatan ini adalah Anda mendapatkan semua yang Anda miliki dari enum, tetapi kode Anda sekarang jauh lebih fleksibel, jadi jika Anda perlu melakukan tindakan yang berbeda berdasarkan nilai Question, Anda dapat memasukkan logika ke dalam Questiondirinya sendiri (yaitu dalam OO yang disukai mode) sebagai kebalikan dari menempatkan banyak pernyataan kasus di seluruh kode Anda untuk menangani setiap skenario.

NB: Jawaban diperbarui 2018-04-27 untuk memanfaatkan fitur C # 6; yaitu ekspresi pernyataan dan definisi tubuh ekspresi lambda. Lihat riwayat revisi untuk kode asli. Ini memiliki manfaat membuat definisi sedikit kurang bertele-tele; yang telah menjadi salah satu keluhan utama tentang pendekatan jawaban ini.

Jika Anda ingin mendapatkan bilangan bulat untuk nilai enum yang disimpan dalam variabel, untuk jenis yang akan digunakan Question, untuk digunakan misalnya dalam suatu metode, Anda bisa melakukan ini yang saya tulis dalam contoh ini:

enum Talen
{
    Engels = 1, Italiaans = 2, Portugees = 3, Nederlands = 4, Duits = 5, Dens = 6
}

Talen Geselecteerd;    

public void Form1()
{
    InitializeComponent()
    Geselecteerd = Talen.Nederlands;
}

// You can use the Enum type as a parameter, so any enumeration from any enumerator can be used as parameter
void VeranderenTitel(Enum e)
{
    this.Text = Convert.ToInt32(e).ToString();
}

Ini akan mengubah judul jendela menjadi 4, karena variabelnya Geselecteerdadalah Talen.Nederlands. Jika saya mengubahnya Talen.Portugeesdan memanggil metode itu lagi, teks akan berubah menjadi 3.

Untuk memastikan nilai enum ada dan kemudian menguraikannya, Anda juga dapat melakukan hal berikut.

// Fake Day of Week
string strDOWFake = "SuperDay";

// Real Day of Week
string strDOWReal = "Friday";

// Will hold which ever is the real DOW.
DayOfWeek enmDOW;

// See if fake DOW is defined in the DayOfWeek enumeration.
if (Enum.IsDefined(typeof(DayOfWeek), strDOWFake))
{
    // This will never be reached since "SuperDay"
    // doesn't exist in the DayOfWeek enumeration.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWFake);
}
// See if real DOW is defined in the DayOfWeek enumeration.
else if (Enum.IsDefined(typeof(DayOfWeek), strDOWReal))
{
    // This will parse the string into it's corresponding DOW enum object.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWReal);
}

// Can now use the DOW enum object.
Console.Write("Today is " + enmDOW.ToString() + ".");

Mungkin saya melewatkannya, tetapi adakah yang mencoba metode ekstensi generik sederhana?

Ini sangat bagus untuk saya. Anda dapat menghindari tipe cast di API Anda dengan cara ini tetapi pada akhirnya itu menghasilkan operasi tipe perubahan. Ini adalah kasus yang bagus untuk pemrograman Roslyn agar kompiler membuat metode GetValue <T> untuk Anda.

    public static void Main()
    {
        int test = MyCSharpWrapperMethod(TestEnum.Test1);

        Debug.Assert(test == 1);
    }

    public static int MyCSharpWrapperMethod(TestEnum customFlag)
    {
        return MyCPlusPlusMethod(customFlag.GetValue<int>());
    }

    public static int MyCPlusPlusMethod(int customFlag)
    {
        // Pretend you made a PInvoke or COM+ call to C++ method that require an integer
        return customFlag;
    }

    public enum TestEnum
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
}

public static class EnumExtensions
{
    public static T GetValue<T>(this Enum enumeration)
    {
        T result = default(T);

        try
        {
            result = (T)Convert.ChangeType(enumeration, typeof(T));
        }
        catch (Exception ex)
        {
            Debug.Assert(false);
            Debug.WriteLine(ex);
        }

        return result;
    }
}

Satu lagi cara untuk melakukannya:

Console.WriteLine("Name: {0}, Value: {0:D}", Question.Role);

Ini akan menghasilkan:

Name: Role, Value: 2

public enum QuestionType
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

... adalah deklarasi yang bagus.

Anda harus memberikan hasilnya ke int seperti:

int Question = (int)QuestionType.Role

Kalau tidak, jenisnya tetap QuestionType.

Tingkat keketatan ini adalah cara C #.

Salah satu alternatif adalah dengan menggunakan deklarasi kelas sebagai gantinya:

public class QuestionType
{
    public static int Role = 2,
    public static int ProjectFunding = 3,
    public static int TotalEmployee = 4,
    public static int NumberOfServers = 5,
    public static int TopBusinessConcern = 6
}

Tidak terlalu elegan untuk dideklarasikan, tetapi Anda tidak perlu memasukkannya dalam kode:

int Question = QuestionType.Role

Atau, Anda mungkin merasa lebih nyaman dengan Visual Basic, yang melayani harapan seperti ini di banyak bidang.

int number = Question.Role.GetHashCode();

numberharus memiliki nilai 2.

Anda dapat melakukan ini dengan menerapkan metode ekstensi ke tipe enum yang Anda tentukan:

public static class MyExtensions
{
    public static int getNumberValue(this Question questionThis)
    {
        return (int)questionThis;
    }
}

Ini menyederhanakan mendapatkan nilai int dari nilai enum saat ini:

Question question = Question.Role;
int value = question.getNumberValue();

atau

int value = Question.Role.getNumberValue();

Gunakan metode ekstensi sebagai gantinya:

public static class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

Dan penggunaannya sedikit lebih cantik:

var intValue = Question.Role.IntValue();

public enum Suit : int
{
    Spades = 0,
    Hearts = 1,
    Clubs = 2,
    Diamonds = 3
}

Console.WriteLine((int)(Suit)Enum.Parse(typeof(Suit), "Clubs"));

// From int
Console.WriteLine((Suit)1);

// From a number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit), 1));

if (typeof(Suit).IsEnumDefined("Spades"))
{
    var res = (int)(Suit)Enum.Parse(typeof(Suit), "Spades");
    Console.Out.WriteLine("{0}", res);
}

Menggunakan:

Question question = Question.Role;
int value = question.GetHashCode();

Itu akan menghasilkan value == 2.

Ini hanya benar jika enum cocok di dalam sebuah int.

Karena enum dapat dideklarasikan dengan beberapa tipe primitif, metode ekstensi umum untuk menggunakan tipe enum apa pun dapat berguna.

enum Box
{
    HEIGHT,
    WIDTH,
    DEPTH
}

public static void UseEnum()
{
    int height = Box.HEIGHT.GetEnumValue<int>();
    int width = Box.WIDTH.GetEnumValue<int>();
    int depth = Box.DEPTH.GetEnumValue<int>();
}

public static T GetEnumValue<T>(this object e) => (T)e;

Berikut ini adalah metode ekstensi

public static string ToEnumString<TEnum>(this int enumValue)
{
    var enumString = enumValue.ToString();
    if (Enum.IsDefined(typeof(TEnum), enumValue))
    {
        enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
    }
    return enumString;
}

Retasan favorit saya dengan enum int atau lebih kecil:

GetHashCode();

Untuk enum

public enum Test
{
    Min = Int32.MinValue,
    One = 1,
    Max = Int32.MaxValue,
}

Ini,

var values = Enum.GetValues(typeof(Test));

foreach (var val in values)
{
    Console.WriteLine(val.GetHashCode());
    Console.WriteLine(((int)val));
    Console.WriteLine(val);
}

output

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Penolakan:

Itu tidak bekerja untuk enum berdasarkan panjang.

Solusi termudah yang dapat saya pikirkan adalah membebani Get(int)metode seperti ini:

[modifiers] Questions Get(Question q)
{
    return Get((int)q);
}

di mana [modifiers]umumnya dapat sama dengan Get(int)metode. Jika Anda tidak dapat mengedit Questionskelas atau karena beberapa alasan tidak mau, Anda dapat membebani metode ini dengan menulis ekstensi:

public static class Extensions
{
    public static Questions Get(this Questions qs, Question q)
    {
        return qs.Get((int)q);
    }
}

Contoh yang ingin saya sarankan "untuk mendapatkan nilai 'int' dari enum", adalah

public enum Sample
{
    Book = 1, 
    Pen = 2, 
    Pencil = 3
}

int answer = (int)Sample.Book;

Sekarang jawabannya adalah 1.

Menggunakan:

Question question = Question.Role;
int value = Convert.ToInt32(question);

Coba yang ini alih-alih konversi enum ke int:

public static class ReturnType
{
    public static readonly int Success = 1;
    public static readonly int Duplicate = 2;
    public static readonly int Error = -1;        
}

Dalam Visual Basic, seharusnya:

Public Enum Question
    Role = 2
    ProjectFunding = 3
    TotalEmployee = 4
    NumberOfServers = 5
    TopBusinessConcern = 6
End Enum

Private value As Integer = CInt(Question.Role)

Saya datang dengan metode ekstensi ini yang mencakup fitur bahasa saat ini. Dengan menggunakan dinamis, saya tidak perlu menjadikan ini metode generik dan menentukan jenis yang membuat doa tetap lebih sederhana dan konsisten:

public static class EnumEx
{
    public static dynamic Value(this Enum e)
    {
        switch (e.GetTypeCode())
        {
            case TypeCode.Byte:
            {
                return (byte) (IConvertible) e;
            }

            case TypeCode.Int16:
            {
                return (short) (IConvertible) e;
            }

            case TypeCode.Int32:
            {
                return (int) (IConvertible) e;
            }

            case TypeCode.Int64:
            {
                return (long) (IConvertible) e;
            }

            case TypeCode.UInt16:
            {
                return (ushort) (IConvertible) e;
            }

            case TypeCode.UInt32:
            {
                return (uint) (IConvertible) e;
            }

            case TypeCode.UInt64:
            {
                return (ulong) (IConvertible) e;
            }

            case TypeCode.SByte:
            {
                return (sbyte) (IConvertible) e;
            }
        }

        return 0;
    }