tutorial - Ottieni un valore int da enum in C#




enum c++ (17)

Ho una classe chiamata Questions (plurale). In questa classe c'è un enum chiamato Question (singolare) che assomiglia a questo.

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

Nella classe Questions , ho una funzione get(int foo) che restituisce un oggetto Questions per quello foo . C'è un modo semplice per ottenere il valore intero dall'enumerazione così posso fare qualcosa come Questions.Get(Question.Role) ?


È più facile di quanto pensi - un enum è già un int. Ha solo bisogno di essere ricordato:

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

È possibile farlo implementando un metodo di estensione al tipo enum definito:

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

Questo semplifica l'acquisizione del valore int del valore attuale di enum:

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

o

int value = Question.Role.getNumberValue();

Che dire invece di un metodo di estensione:

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

E l'utilizzo è leggermente più bello:

var intValue = Question.Role.IntValue();

Di seguito è riportato il metodo di estensione

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

Esempio:

Public Enum EmpNo
{
    Raj = 1
    Rahul,
    Priyanka
}

E nel codice dietro per ottenere valore enum:

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

o

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

Le enumerazioni aumenteranno di 1 ed è possibile impostare il valore iniziale. Altrimenti sarà assegnato inizialmente a 0.


Forse l'ho perso ma qualcuno ha provato un semplice metodo di estensione generico. Questo funziona alla grande per me. È possibile evitare il cast del tipo nella propria API in questo modo, ma alla fine risulta un'operazione di tipo change. Questo è un buon caso per programmare Roselyn affinché il compilatore faccia un metodo GetValue per te.

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

L'esempio che vorrei suggerire 'ottenere il valore' int 'da enum è'

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

int answer = (int)Sample.Book;

ora la risposta sarà 1.

Spero che questo possa aiutare qualcuno.


La soluzione più semplice che riesco a pensare è di sovraccaricare il metodo Get(int) questo modo:

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

dove [modifiers] può essere generalmente uguale al metodo Get(int) . Se non è possibile modificare la classe Questions o per qualche motivo non si desidera, è possibile sovraccaricare il metodo scrivendo un'estensione:

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

Per garantire che esista un valore enum e quindi analizzarlo, puoi anche fare quanto segue.

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

Spero che questo possa essere d'aiuto.


Poiché Enum può essere un qualsiasi tipo integrale ( byte , int , short , ecc.), Un modo più efficace per ottenere il valore integrale sottostante GetTypeCode quello di utilizzare il metodo GetTypeCode in combinazione con la classe Convert :

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

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

Questo dovrebbe funzionare indipendentemente dal tipo integrale sottostante.


Prova questo :

int value = YourEnum.ToString("D");

Prova questo invece di convertire enum in int:

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

Se si desidera ottenere un numero intero per il valore enum memorizzato in una variabile, il cui tipo sarebbe Question , da utilizzare ad esempio in un metodo, è sufficiente eseguire ciò che ho scritto in questo esempio:

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

Questo cambierà il titolo della finestra in 4 perché la variabile Geselecteerd è Talen.Nederlands . Se lo cambio a Talen.Portugees e chiamo di nuovo il metodo, il testo cambierà in 3.

Ho avuto difficoltà a trovare questa semplice soluzione su Internet e non riuscivo a trovarla, quindi stavo testando qualcosa e ho scoperto questo. Spero che questo ti aiuti. ;)


Su una nota correlata, se si desidera ottenere il valore int da System.Enum , quindi dato e qui:

Enum e = Question.Role;

Puoi usare:

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

Gli ultimi due sono semplicemente brutti. Preferisco il primo.


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

Risulterà in value == 2 .


int number = Question.Role.GetHashCode();

number dovrebbe avere il valore 2 .


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




int