Obter valor int de enum em C #

Eu tenho uma classe chamada Questions(plural). Nesta classe, há um enum chamado Question(singular) que se parece com isso.

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

Na Questionsclasse, tenho uma get(int foo)função que retorna um Questionsobjeto para isso foo. Existe uma maneira fácil de obter o valor inteiro da enumeração para que eu possa fazer algo assim Questions.Get(Question.Role)?

Basta lançar o enum, por exemplo

int something = (int) Question.Role;

O exemplo acima funcionará para a grande maioria de enumerações que você vê na natureza, como o tipo subjacente padrão de uma enumeração int.

No entanto, como cecilphillip aponta, as enumerações podem ter diferentes tipos subjacentes. Se um ENUM é declarado como um uint, longou ulong, deve ser convertido para o tipo de enumeração; por exemplo, para

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

você deveria usar

long something = (long)StarsInMilkyWay.Wolf424B;

Desde Enums pode ser qualquer tipo integral ( byte, int, short, etc.), uma forma mais robusta para obter o valor integral subjacente da enumeração seria fazer uso do GetTypeCodemétodo em conjunto com a Convertclasse:

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

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

Isso deve funcionar independentemente do tipo integral subjacente.

Declare-o como uma classe estática com 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;
}

E então você pode fazer referência a ele como Question.Role, e ele sempre é avaliado como um intou o que você definir como.

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

Irá resultar em value == 2.

Em uma nota relacionada, se você deseja obter o intvalor System.Enum, especifique eaqui:

Enum e = Question.Role;

Você pode 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);

Os dois últimos são feios. Eu prefiro o primeiro.

É mais fácil do que você pensa - um enum já é um int. Só precisa ser lembrado:

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

Exemplo:

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

E no código por trás para obter o valor enum:

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

ou

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

As enums serão incrementadas em 1 e você poderá definir o valor inicial. Se você não definir o valor inicial, ele será atribuído como 0 inicialmente.

Recentemente, converti o uso de enumerações no meu código em vez de usar classes com construtores protegidos e instâncias estáticas predefinidas (graças ao Roelof - C # Garantir valores válidos de enumeração - método à prova de futuro ).

À luz disso, veja abaixo como eu abordaria esse problema agora (incluindo a conversão implícita de / para 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)
}

A vantagem dessa abordagem é que você obtém tudo o que teria da enumeração, mas seu código agora é muito mais flexível; portanto, se você precisar executar ações diferentes com base no valor de Question, poderá colocar a lógica em Questionsi (por exemplo, no OO preferido moda), em vez de colocar muitas instruções de caso em todo o código para lidar com cada cenário.

NB: Resposta atualizada em 2018-04-27 para fazer uso dos recursos do C # 6; ou seja, expressões de declaração e definições de corpo de expressão lambda. Veja o histórico de revisões para obter o código original. Isso tem o benefício de tornar a definição um pouco menos detalhada; que havia sido uma das principais reclamações sobre a abordagem dessa resposta.

Se você deseja obter um número inteiro para o valor de enum que é armazenado em uma variável, para o qual o tipo seria Question, para usar, por exemplo, em um método, basta fazer isso que escrevi neste exemplo:

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

Isso mudará o título da janela para 4, porque a variável Geselecteerdé Talen.Nederlands. Se eu mudar para Talen.Portugeese chamar o método novamente, o texto será alterado para 3.

Para garantir que exista um valor de enumeração e depois analisá-lo, você também pode fazer o seguinte.

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

Talvez eu tenha perdido, mas alguém já tentou um método simples de extensão genérica?

Isso funciona muito bem para mim. Você pode evitar o tipo de conversão na sua API dessa maneira, mas, em última análise, resulta em uma operação de tipo de alteração. Este é um bom caso para programar o Roslyn para que o compilador crie um método GetValue <T> para você.

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

Mais uma maneira de fazer isso:

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

Isso resultará em:

Name: Role, Value: 2

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

... é uma boa declaração.

Você precisa converter o resultado para int da seguinte maneira:

int Question = (int)QuestionType.Role

Caso contrário, o tipo é imóvel QuestionType.

Esse nível de rigor é o modo C #.

Uma alternativa é usar uma declaração de 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
}

É menos elegante declarar, mas você não precisa convertê-lo no código:

int Question = QuestionType.Role

Como alternativa, você pode se sentir mais confortável com o Visual Basic, que atende a esse tipo de expectativa em muitas áreas.

int number = Question.Role.GetHashCode();

numberdeve ter o valor 2.

Você pode fazer isso implementando um método de extensão para o seu tipo de enum definido:

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

Isso simplifica a obtenção do valor int do valor atual da enumeração:

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

ou

int value = Question.Role.getNumberValue();

Use um método de extensão:

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

E o uso é um pouco mais bonito:

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

Usar:

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

Isso resultará em value == 2.

Isso só é verdade se o enum se encaixar dentro de um int.

Como as enumerações podem ser declaradas com vários tipos primitivos, um método de extensão genérico para converter qualquer tipo de enumeração pode ser útil.

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;

A seguir está o método de extensão

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

Meu hack favorito com enums int ou menores:

GetHashCode();

Para um enum

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

Este,

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

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

saídas

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Aviso Legal:

Não funciona para enumerações baseadas em muito tempo.

A solução mais fácil que consigo pensar é sobrecarregar o Get(int)método desta maneira:

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

onde [modifiers]geralmente pode ser o mesmo que para o Get(int)método Se você não pode editar a Questionsclasse ou, por algum motivo, não quiser, pode sobrecarregar o método escrevendo uma extensão:

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

O exemplo que eu gostaria de sugerir "para obter um valor 'int' de uma enumeração" é

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

int answer = (int)Sample.Book;

Agora a resposta será 1.

Usar:

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

Tente este em vez de converter enum para int:

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

No Visual Basic, deve ser:

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

Private value As Integer = CInt(Question.Role)

Eu vim com esse método de extensão que inclui recursos de idioma atuais. Ao usar dinâmico, não preciso fazer disso um método genérico e especificar o tipo que mantém a chamada mais simples e consistente:

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