Pregunta Obtenga el valor int de enum en C #


Tengo una clase llamada Questions (plural). En esta clase hay una enumeración llamada Question (singular) que se parece a esto.

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

En el Questions clase, tengo un get(int foo) función que devuelve un Questions objeto para eso foo. ¿Hay una forma fácil de obtener el valor entero de la enumeración para que pueda hacer algo como Questions.Get(Question.Role)?


1367
2018-06-03 06:46


origen


Respuestas:


Solo echa la enumeración, p.

int something = (int) Question.Role;

Lo anterior funcionará para la gran mayoría de enumeraciones que ves en la naturaleza, ya que el tipo subyacente por defecto para una enumeración es int.

Sin embargo, como Cecilphillip señala, las enumeraciones pueden tener diferentes tipos subyacentes. Si una enumeración se declara como uint, long, o ulong, debe ser lanzado al tipo de la enumeración; p.ej. para

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

Deberías usar

long something = (long)StarsInMilkyWay.Wolf424B;

1795
2018-06-03 06:49



Dado que los Enums pueden ser de cualquier tipo integral (byte, int, short, etc.), una forma más sólida de obtener el valor integral subyacente de la enumeración sería hacer uso de la GetTypeCode método en conjunción con el Convert clase:

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

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

Esto debería funcionar independientemente del tipo integral subyacente.


237
2017-07-09 14:54



Declararlo como una clase estática con constantes públicas:

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

Y luego puedes referenciarlo como Question.Role, y siempre se evalúa como int o lo que sea que lo defines como


162
2018-06-15 19:28



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

Resultará en value == 2.


72
2018-06-03 06:48



En una nota relacionada, si quieres obtener el int valor de System.Enum, luego dado e aquí:

Enum e = Question.Role;

Puedes usar:

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

Los dos últimos son feos. Prefiero la primera.


54
2017-12-01 08:47



Es más fácil de lo que piensas, una enumeración ya es una int. Solo necesita ser recordado:

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

30
2018-06-03 06:51



Ejemplo:

Public Enum EmpNo
{
    Raj = 1
    Rahul,
    Priyanka
}

Y en el código detrás para obtener el valor enum:

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

o

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

Los mensajes se incrementarán en 1, y puede establecer el valor de inicio. De lo contrario, se asignará como 0 inicialmente.


22
2017-09-25 10:43



Recientemente, he evitado el uso de enumeraciones en mi código a favor de usar clases con constructores protegidos e instancias estáticas predefinidas (gracias a Roelof - C # Asegura valores válidos de Enum - Método a prueba de futuro)

A la luz de esto, a continuación se explica cómo abordaría este problema (incluida la conversión implícita a / desde 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)
}

La ventaja de este enfoque es que obtienes todo lo que obtendrías de la enumeración, pero ahora tu código es mucho más flexible, por lo que deberías realizar diferentes acciones basadas en el valor de Question, puedes poner la lógica en Question en sí mismo (es decir, en la moda OO preferida) en lugar de poner muchas declaraciones de casos a lo largo de su código para abordar cada situación.


NB: Respuesta actualizada 2018-04-27 para hacer uso de las características C # 6; es decir, expresiones de declaración y definiciones corporales de expresiones lambda. Ver revisión histórica para el código original. Esto tiene el beneficio de hacer que la definición sea un poco menos detallada; que ha sido una de las principales quejas sobre el enfoque de esta respuesta.


18
2018-03-30 01:08