C # enum int int değeri alın

Questions(Çoğul) adında bir sınıfım var . Bu sınıfta buna Questionbenzeyen (tekil) bir numaralandırma vardır .

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

In Questionssınıfında Bir var get(int foo)bir döndüren işlevi Questionsbunun için nesneyi foo. Böyle bir şey yapabilmem için enum tamsayı değerini almak için kolay bir yolu var mı Questions.Get(Question.Role)?

Numaralandırmayı yapın, örn.

int something = (int) Question.Role;

Yukarıdakiler, bir numaralandırma için varsayılan altta yatan tür olduğu gibi, doğada gördüğünüz enumların büyük çoğunluğu için çalışacaktır int.

Bununla birlikte, cecilphillip'in işaret ettiği gibi , numaralandırmaların altta yatan farklı türleri olabilir. Bir enum bir ilan edilirse uint, longya ulong, enum tipine atılmalıdır; örneğin

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

kullanmalısın

long something = (long)StarsInMilkyWay.Wolf424B;

Numaralamalar bir entegre tip olabilir yana ( byte, int, shortve benzeri), enum temel tamamlayıcı değeri elde etmek için daha sağlam bir yolu faydalanmak olacaktır GetTypeCodebağıntılı olarak kullanılması, Convertsınıf:

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

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

Bu, temel integral türünden bağımsız olarak çalışmalıdır.

Genel sabitleri olan statik bir sınıf olarak bildirin:

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

Ve sonra bunu olarak tanımlayabilirsiniz ve her zaman onu tanımladığınız Question.Rolebir intveya her şeye göre değerlendirir .

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

İle sonuçlanır value == 2.

İlgili bir notta, intdeğeri almak istiyorsanız System.Enum, o zaman eburada verilir :

Enum e = Question.Role;

Kullanabilirsiniz:

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

Son ikisi çirkin. İlkini tercih ederim.

Düşündüğünüzden daha kolay - bir numaralandırma zaten bir int. Sadece hatırlatılması gerekir:

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

Misal:

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

Ve enum değerini almak için arkadaki kodda:

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

veya

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

Numaralandırmalar 1 artar ve başlangıç ​​değerini ayarlayabilirsiniz. Başlangıç ​​değerini ayarlamazsanız, başlangıçta 0 olarak atanacaktır.

Yakın zamanda korumalı yapıcılar ve önceden tanımlanmış statik örnekleri (Roelof - C # sağlamak geçerli numaralandırma değerleri - Futureproof yöntemi sayesinde) yerine sınıflarımda numaralandırma kullanmaktan dönüştürdüm .

Bunun ışığında, şimdi bu konuya nasıl yaklaşacağım aşağıdadır (üstü kapalı / dönüşüm dahil 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)
}

Bu yaklaşımın avantajı, numaradan alacağınız her şeyi elde etmenizdir, ancak kodunuz artık çok daha esnektir, bu nedenle değerine bağlı olarak farklı eylemler gerçekleştirmeniz gerekiyorsa Question, kendinize mantık koyabilirsiniz Question(yani tercih edilen OO'da) moda) kodunuz boyunca her senaryoyu ele almak için birçok vaka ifadesi koymak yerine.

Not: Cevap C # 6 özelliklerinden yararlanmak için 2018-04-27 güncellendi; yani ifade ifadeleri ve lambda ifade gövdesi tanımları. Orijinal kod için düzeltme geçmişine bakın . Bu, tanımı biraz daha az ayrıntılı hale getirme avantajına sahiptir; bu yanıtın yaklaşımı ile ilgili ana şikayetlerden biri olmuştur.

QuestionÖrneğin, bir yöntemde kullanmak için tür olacağını, bir değişken saklanan enum değeri için bir tamsayı almak istiyorsanız, basitçe bu örnekte yazdım bunu yapabilirsiniz:

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

Değişken Geselecteerdolduğu için bu pencere başlığını 4 olarak değiştirir Talen.Nederlands. Bunu değiştirir Talen.Portugeesve yöntemi tekrar çağırırsam, metin 3 olarak değişir.

Bir enum değerinin var olmasını ve sonra ayrıştırılmasını sağlamak için aşağıdakileri de yapabilirsiniz.

// 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() + ".");

Belki özledim, ama kimse basit bir genel uzantısı yöntemi denedi?

Bu benim için harika çalışıyor. API'nıza bu türden döküm türünü bu şekilde önleyebilirsiniz, ancak sonuçta bir değişiklik türü işlemi ile sonuçlanır. Bu programlama için iyi bir durumdur Roslyn derleyici sizin için GetValue <T> yöntemi yapmak zorunda.

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

Bunu yapmanın bir yolu daha:

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

Sonuç:

Name: Role, Value: 2

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

... güzel bir deklarasyon.

Sonucu şöyle yapmak zorundasınız:

int Question = (int)QuestionType.Role

Aksi takdirde, tür hala sabittir QuestionType.

Bu katılık düzeyi C # yoludur.

Alternatiflerden biri, sınıf bildirimi kullanmaktır:

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
}

Bildirmek daha az zariftir, ancak kodda yayınlamanıza gerek yoktur:

int Question = QuestionType.Role

Alternatif olarak, birçok alanda bu tür bir beklentiyi karşılayan Visual Basic ile daha rahat hissedebilirsiniz.

int number = Question.Role.GetHashCode();

numberdeğeri olmalı 2.

Tanımladığınız numaralandırma türüne bir uzantı yöntemi uygulayarak bunu yapabilirsiniz :

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

Bu, geçerli numaralandırma değerinin int değerini almayı kolaylaştırır:

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

veya

int value = Question.Role.getNumberValue();

Bunun yerine bir uzantı yöntemi kullanın:

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

Ve kullanım biraz daha güzel:

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

kullanın:

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

Sonuçlanacak value == 2 .

Bu sadece enum bir içine sığarsa doğrudur int.

Numaralandırmalar birden fazla ilkel türle bildirilebildiğinden, herhangi bir numaralandırma türünü dökmek için genel bir genişletme yöntemi yararlı olabilir.

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;

Uzantı yöntemi aşağıdadır

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

Int veya daha küçük numaralarla en sevdiğim kesmek:

GetHashCode();

Bir numaralandırma için

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

Bu,

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

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

çıktılar

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Yasal Uyarı:

Uzun süre dayanan numaralandırmalar için çalışmaz.

Düşünebildiğim en kolay çözüm, Get(int)yöntemi bu şekilde aşırı yüklemektir :

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

burada [modifiers]genellikle yöntemle aynı olabilir Get(int). QuestionsSınıfı düzenleyemiyorsanız veya herhangi bir nedenle istemiyorsanız, bir uzantı yazarak yöntemi aşırı yükleyebilirsiniz:

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

"Bir numaralandırmadan 'int' değeri almak için" önermek istediğim örnek şudur:

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

int answer = (int)Sample.Book;

Şimdi cevap 1 olacak.

kullanın:

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

Enum'u int'e dönüştürmek yerine bunu deneyin:

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

Visual Basic'te şöyle olmalıdır:

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

Private value As Integer = CInt(Question.Role)

Mevcut dil özelliklerini içeren bu uzatma yöntemini buldum. Dinamik kullanarak, bu genel bir yöntem yapmak ve çağırma basit ve tutarlı tutan türü belirtmek gerekmez:

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