c# convert to - Ottieni un valore int da enum in C #





12 Answers

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.

integer tutorial 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 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) ?




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

Risulterà in value == 2 .




È 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



Recentemente mi sono convertito dall'usare le enumerazioni nel mio codice in favore di usare invece classi con costruttori protetti e istanze statiche predefinite (grazie a Roelof - C # Garantire Valid Enum Values ​​- Futureproof Method ).

Alla luce di ciò, di seguito è come vorrei ora affrontare questo problema (compresa la conversione implicita in / da 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 vorresti dall'enumerazione, ma il tuo codice ora è molto più flessibile, quindi se dovessi eseguire azioni diverse in base al valore di Question , puoi inserire la logica nella Question stessa (cioè nel modalità OO preferita) anziché mettere un sacco di istruzioni caso per tutto il codice per affrontare ogni scenario.

NB: rispondere aggiornato 2018-04-27 per utilizzare le funzionalità di C # 6; cioè espressioni di dichiarazione e definizioni del corpo di espressione lambda. Vedi la cronologia delle revisioni per il codice originale. Questo ha il vantaggio di rendere la definizione un po 'meno prolissa; che era stata una delle principali lamentele sull'approccio di questa risposta.




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.




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



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



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 Vb. Dovrebbe essere

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

Private value As Integer = CInt(Question.Role)



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





Related