Ottieni il valore int da enum in C #

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 Questionsclasse ho una get(int foo)funzione che restituisce un Questionsoggetto per quello foo. C'è un modo semplice per ottenere il valore intero dall'enum in modo che io possa fare qualcosa del genere Questions.Get(Question.Role)?

Basta lanciare l'enum, ad es

int something = (int) Question.Role;

Quanto sopra funzionerà per la stragrande maggioranza degli enum che vedi in natura, come è il tipo di base predefinito per un enum int.

Tuttavia, come cecilphillip sottolinea, enumerazioni possono avere diversi tipi sottostanti. Se un enum è dichiarata come uint, longo ulong, deve essere gettato al tipo di enum; ad es. per

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

dovresti usare

long something = (long)StarsInMilkyWay.Wolf424B;

Poiché Enums può essere qualsiasi tipo integrale ( byte, int, short, ecc), un modo più robusto per ottenere il valore integrale sottostante dell'enumerazione sarebbe quello di utilizzare il GetTypeCodemetodo unitamente con la Convertclasse:

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.

Dichiararlo come una classe statica con costanti pubbliche:

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

E poi puoi fare riferimento come Question.Role, e valuta sempre a into qualunque cosa tu lo definisca.

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

Ne risulterà value == 2.

In una nota correlata, se si desidera ottenere il intvalore da System.Enum, quindi indicato equi:

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.

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

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

Esempio:

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

E nel codice dietro per ottenere il valore enum:

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

o

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

Gli enumerazioni aumenteranno di 1 e sarà possibile impostare il valore iniziale. Se non si imposta il valore iniziale, verrà assegnato inizialmente come 0.

Di recente mi sono convertito dall'uso di enum nel mio codice in favore dell'utilizzo invece di classi con costruttori protetti e istanze statiche predefinite (grazie a Roelof - C # Assicurare valori di enum validi - Metodo a prova di futuro ).

Alla luce di ciò, di seguito è come ora affronterei questo problema (inclusa la conversione implicita da / a 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)
}

Il vantaggio di questo approccio è che ottieni tutto ciò che avresti dall'enum, ma il tuo codice ora è molto più flessibile, quindi se dovessi eseguire diverse azioni in base al valore di Question, puoi mettere la logica in Questionse stessa (cioè nell'OO preferito moda) invece di inserire molte dichiarazioni di casi in tutto il codice per affrontare ogni scenario.

NB: Risposta aggiornata 27-04-2018 per utilizzare le funzionalità di C # 6; vale a dire espressioni di dichiarazione e definizioni del corpo di espressioni lambda. Vedi la cronologia delle revisioni per il codice originale. Ciò ha il vantaggio di rendere la definizione un po 'meno dettagliata; che era stata una delle principali lamentele riguardo all'approccio di questa risposta.

Se vuoi ottenere un numero intero per il valore enum che è memorizzato in una variabile, per la quale sarebbe il tipo Question, da usare ad esempio in un metodo, puoi semplicemente farlo 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 Talen.Portugeese richiamo nuovamente il metodo, il testo cambierà in 3.

Per assicurarsi che esista un valore enum e quindi analizzarlo, è anche possibile effettuare le seguenti operazioni.

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

Forse l'ho perso, ma qualcuno ha provato un semplice metodo di estensione generico?

Questo funziona alla grande per me. In questo modo puoi evitare il cast di tipi nella tua API, ma alla fine si traduce in un'operazione di modifica del tipo. Questo è un buon caso per programmare Roslyn in modo che il compilatore faccia un metodo GetValue <T> 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;
    }
}

Un altro modo per farlo:

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

Si tradurrà in:

Name: Role, Value: 2

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

... è una bella dichiarazione.

Devi trasmettere il risultato a int in questo modo:

int Question = (int)QuestionType.Role

Altrimenti, il tipo è fermo QuestionType.

Questo livello di rigore è il modo C #.

Un'alternativa è invece utilizzare una dichiarazione di classe:

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
}

È meno elegante da dichiarare, ma non è necessario lanciarlo nel codice:

int Question = QuestionType.Role

In alternativa, potresti sentirti più a tuo agio con Visual Basic, che soddisfa questo tipo di aspettativa in molte aree.

int number = Question.Role.GetHashCode();

numberdovrebbe avere il valore 2.

Puoi farlo implementando un metodo di estensione per il tuo tipo enum definito:

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

Questo semplifica ottenere il valore int del valore enum corrente:

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

o

int value = Question.Role.getNumberValue();

Utilizzare invece un metodo di estensione:

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

E l'uso è leggermente più bello:

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

Uso:

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

Ne risulterà value == 2.

Questo è vero solo se l'enum si inserisce all'interno di un int.

Poiché gli enum possono essere dichiarati con più tipi primitivi, può essere utile un metodo di estensione generico per lanciare qualsiasi tipo di enum.

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;

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

Il mio hack preferito con enumerazioni int o minori:

GetHashCode();

Per un enum

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

Questo,

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

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

uscite

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Disclaimer:

Non funziona per enumerazioni basate su lunghe.

La soluzione più semplice che mi viene in mente è sovraccaricare il Get(int)metodo in questo modo:

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

dove [modifiers]può essere generalmente lo stesso del Get(int)metodo. Se non riesci a modificare la Questionsclasse o per qualche motivo non vuoi, puoi sovraccaricare il metodo scrivendo un'estensione:

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

L'esempio che vorrei suggerire "per ottenere un valore" int "da un enum" è

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

int answer = (int)Sample.Book;

Ora la risposta sarà 1.

Uso:

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

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

In Visual Basic, dovrebbe essere:

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

Private value As Integer = CInt(Question.Role)

Ho ideato questo metodo di estensione che include le funzionalità della lingua corrente. Usando dinamico, non ho bisogno di renderlo un metodo generico e specificare il tipo che mantiene l'invocazione più semplice e coerente:

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