Obtenga el valor int de la enumeración en C #

Tengo una clase llamada Questions (plural). En esta clase hay una enumeración llamada Question (singular) que tiene este aspecto.

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

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

preguntado el 03 de junio de 09 a las 03:06

Sé que llego tarde a la fiesta, pero en lugar de definir tu método como get(int foo) puedes definirlo como get(Question foo) luego haz tu casting dentro del método, puedes llamar a tu método como Questions.Get(Question.Role) -

29 Respuestas

Simplemente lanza la enumeración, p. Ej.

int something = (int) Question.Role;

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

No obstante, como cecilfilip señala, las enumeraciones pueden tener diferentes tipos subyacentes. Si una enumeración se declara como uint, long o el ulong, debe convertirse en el tipo de enumeración; p. ej. para

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

Deberías usar

long something = (long)StarsInMilkyWay.Wolf424B;

Respondido 27 Feb 18, 15:02

@Harry, no es cierto. Puede crear enumeración sin conversión, no es necesario. y solo asigno número en casos especiales, la mayoría de las veces lo dejo como valor por defecto. pero tu puedes hacer enum Test { Item = 1 } y ver eso 1 == (int)Test.Item es igual. - Jaider

@Jaider (int)Test.Item ¡Eso es un yeso! () es el operador de conversión explícito. - sinthia v

@Sinthia V dijo que puedes Para crear sin fundir, lo cual es correcto - Pablo Ridgway

Si el tipo subyacente de enum Question no era int pero long este elenco se truncará Roles valor integral! - Quaylar

Cuando aceptas un Enum como parámetro, sabe que es solo un número fijo de posibles valores integrales que puede obtener. Por otro lado, si toma simplemente un int, entonces tienes que validar si eso int está dentro de los valores aceptados, lo que complica el código. Siempre puede anular sus firmas como `` `public void MyMethod (int x) {// hacer algo con x} public void MyMethod (Enum x) {this.MyMethod ((int) x); } `` `` - Percebus

Dado que Enums puede ser cualquier tipo integral (byte, int, short, etc.), una forma más robusta 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.

Respondido 27 Feb 18, 15:02

Esta técnica me demostró su valor cuando se trataba de un tipo genérico donde T: enum (en realidad, T: struct, IConvertible, pero esa es una historia diferente). - aboy021

¿Cómo modificaría esto para imprimir el valor hexadecimal del lado? Este ejemplo muestra el valor decimal. El problema es ese var es de tipo object, así que tienes que desempacarlo y se pone más complicado de lo que me gustaría. - marca lakata

Si desea convertir a int intente (en el caso de una enumeración Sides: int) [...] object val = Convert.ChangeType (side, typeof (int)); [...] - la Ley

@TimAbell Todo lo que realmente puedo decir es que descubrimos que las páginas aspx compiladas dinámicamente (donde tienes que implementar los archivos .cs en el servidor en vivo) asignaban los números enteros de manera diferente a cada valor. Eso significaba que los objetos serializados en una máquina, se deserializaban con diferentes valores en una máquina diferente y se corrompían efectivamente (causando horas de confusión). Lo planteamos con MS y creo recordar que dijeron que no se garantizaba que los enteros generados automáticamente fueran los mismos cuando se compilaban en diferentes versiones de framework. - NickG

@TimAbell En otra ocasión, un desarrollador eliminó un valor Enum obsoleto / no utilizado, lo que provocó que todos los demás valores de la secuencia salieran en uno. Como tal, nuestros estándares de codificación ahora requieren que los ID siempre se especifiquen explícitamente; de ​​lo contrario, agregar / eliminar o incluso formatear automáticamente el código (por ejemplo, ordenar alfabéticamente) cambiará todos los valores y provocará daños en los datos. Recomendaría encarecidamente a cualquiera que especifique todos los números enteros de Enum explícitamente. Esto es muy importante si se correlacionan con valores almacenados externamente (base de datos). - NickG

Declararlo como una clase estática que tiene 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 puede hacer referencia a él como Question.Role, y siempre se evalúa como un int o como lo defina.

Respondido 27 Feb 18, 16:02

Yo usaría static readonly int porque las constantes se compilan en sus valores duros. Ver stackoverflow.com/a/755693/492 - Tipo CAD

Esta solución en realidad no proporciona el beneficio real de enumeraciones fuertemente tipadas. Si solo quisiera pasar un parámetro GameState-enum-parameter a un método específico, por ejemplo, el compilador no debería permitirme pasar ninguna variable int como parámetro. - thgc

@CADBloke, que es precisamente la razón por la que usarías const y no static readonly porque cada vez que comparas static readonly estás haciendo una llamada a un método para obtener el valor de la variable mientras que con un const está comparando dos tipos de valores directamente. - bucle de bloque

@ brettof86 Sí, una constante sería más rápida, si la limitación de compilación nunca será un problema, entonces todo está bien. - Tipo CAD

@Zack No lo expliqué muy bien, por compilation limitation Quiero decir que el valor está codificado cuando lo compila, por lo que cualquier cambio en ese valor requeriría que todos los los ensamblados que lo utilizan deben volver a compilarse. Me inclino a estar de acuerdo con usted sobre el uso porque cambiar los valores tendría implicaciones de gran alcance. - Tipo CAD

En una nota relacionada, si desea 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.

Respondido 13 ago 15, 01:08

Sin embargo, el segundo es el más rápido. - johan b

Como alguien que está acostumbrado a usar Mixins en la modificación de Minecraft, el segundo parece ser el ganador obvio. - Sollace

Y la quinta opción (como dice la mayoría de las respuestas) es: int i = (int) e; (sin lanzar al objeto primero) - andreyk2 Hohlov

@ andreyk2Hohlov Cannot convert type 'System.Enum' to 'int' - nawfal

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

Resultará en value == 2.

Respondido el 03 de junio de 09 a las 07:06

Entonces, algo como este Questions.Get (Convert.ToInt16 (Question.Applications)) - jim

Simplemente puede lanzar en cualquier dirección; lo único que hay que observar es que las enumeraciones no imponen nada (el valor de la enumeración podría ser 288, aunque no exista ninguna pregunta con ese número) - Marc Gravell ♦

@jim: No, simplemente envíe el valor: Questions.Get ((int) Question.Applications); - Guffa

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

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

Respondido el 08 de diciembre de 19 a las 16:12

quisquilloso: este enum ya es un int. Otras enumeraciones pueden ser de diferentes tipos; pruebe "enum SmallEnum: byte {A, B, C}" - mqp

Totalmente cierto. Referencia de C #: "Cada tipo de enumeración tiene un tipo subyacente, que puede ser cualquier tipo integral excepto char". - miguel petrotta

Ejemplo:

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

Y en el código detrás para obtener el valor de enumeración:

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

or

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

Las enumeraciones se incrementarán en 1 y puede establecer el valor inicial. Si no establece el valor inicial, se asignará inicialmente como 0.

Respondido 24 Oct 20, 09:10

¿Puede algo que es un Raj ser también un Rahul o un Priyanka? Sus valores entran en conflicto y deben duplicarse para ser únicos, por ejemplo, 0, 1, 2, 4, 8, etc. Esta es mi principal preocupación con las enumeraciones. - Timothy González

@TimothyGonzalez en realidad enumeraciones simplemente cuenta 1 si no especifica explícitamente su valor;) - derHugo

@derHugo eso depende si asume que los valores numéricos son base 10 o base 2. - Timothy González

@TimothyGonzalez bueno, no hay mucho que asumir ... Acabo de señalar que por defecto solo cuentan hacia arriba 1 in int excepto que defina explícitamente lo contrario - derHugo

Recientemente he dejado de usar enumeraciones en mi código a favor de usar clases con constructores protegidos e instancias estáticas predefinidas (gracias a Roelof - C # Garantizar valores de enumeración válidos: método a prueba de futuro).

A la luz de eso, a continuación se muestra 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 obtiene todo lo que tendría de la enumeración, pero su código ahora es mucho más flexible, por lo que debe realizar diferentes acciones en función del valor de Question, puedes poner lógica en Question en sí mismo (es decir, en la forma OO preferida) en lugar de poner muchas declaraciones de casos a lo largo de su código para abordar cada escenario.


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

Respondido 27 Abr '18, 09:04

Supongo que es el intercambio entre el reparto explícito y el código que tienes que escribir para eludirlo. Todavía me encanta la implementación, solo desearía que no fuera tan larga. +1 - user692942

He usado varios tipos diferentes de clases estructuradas de manera similar a esta. Encuentro que funcionan de maravilla cuando trato de seguir la metodología de "no me dejes ser un idiota después". - james haug

Si desea obtener un número entero para el valor de enumeración que se almacena en una variable, para el cual el tipo sería Question, para usar, por ejemplo, en un método, simplemente puede hacer esto que escribí en este ejemplo:

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

Esto cambiará el título de la ventana a 4, porque la variable Geselecteerd is Talen.Nederlands. Si lo cambio a Talen.Portugees y vuelva a llamar al método, el texto cambiará a 3.

Respondido el 08 de diciembre de 19 a las 16:12

Desafortunadamente, este enfoque ofrece un rendimiento deficiente cuanto más lo use. Lo probé en algún código mío y, a medida que pasaba el tiempo, mi aplicación se volvió más y más lenta, con cada vez menos uso de la CPU. Esto implicaba que los subprocesos estaban esperando algo: supongo que se trata de algún tipo de recolección de basura, posiblemente debido a que se encajona el parámetro enum en ToInt32 (). Al cambiar a un int.Parse () simple, pude eliminar este bajo rendimiento por completo, y el rendimiento se mantuvo igual sin importar cuánto tiempo se ejecutó el código. - Greg

Para asegurarse de que existe un valor de enumeración y luego analizarlo, también puede hacer lo siguiente.

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

Respondido el 08 de diciembre de 19 a las 16:12

Una forma más de hacerlo:

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

Dará como resultado:

Name: Role, Value: 2

Respondido el 08 de diciembre de 19 a las 17:12

Esta fue la mejor solución para mi caso de uso, ya que mis enumeraciones eran una mezcla de valores int y long - Andy

Tal vez me lo perdí, pero ¿alguien ha probado un método de extensión genérico simple?

Esto funciona muy bien para mí. Puede evitar la conversión de tipos en su API de esta manera, pero finalmente da como resultado una operación de cambio de tipo. Este es un buen caso para programar Roslyn para que el compilador haga un GetValue método para ti.

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

Respondido el 08 de diciembre de 19 a las 17:12

¿Posiblemente porque hacer (int) customFlag es escribir menos y hace más o menos lo mismo? - Tim Keating

Re "Quizás me lo perdí, pero ¿alguien ha probado un simple genérico método de extensión?": SixOThree dijo "Utilice un método de extensión en lugar de" y Bronek dijo "Puede hacer esto implementando una método de extensión a su tipo de enumeración definido ". - Pedro Mortensen

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

... es una buena declaración.

Tienes que lanzar el resultado a int así:

int Question = (int)QuestionType.Role

De lo contrario, el tipo sigue siendo QuestionType.

Este nivel de rigor es el método de C #.

Una alternativa es usar una declaración de clase en su lugar:

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
}

Es menos elegante de declarar, pero no es necesario convertirlo en código:

int Question = QuestionType.Role

Alternativamente, puede sentirse más cómodo con Visual Basic, que satisface este tipo de expectativas en muchas áreas.

Respondido 27 Feb 18, 17:02

int number = Question.Role.GetHashCode();

number debería tener el valor 2.

Respondido 27 Oct 15, 12:10

GetHashCode es una forma de obtener valor de la máscara común Enum - Gracias

Tenga en cuenta que esto solo es "legítimo" para bool*, byte, ushort, inty uint**. El GetHashCode para otros tipos modifica el valor, por ejemplo, hace algunos cambios de bits y xors. (* 1/0, ** convertido a int por supuesto). Pero en general, no hagas esto a menos que sea tu propio código privado. - anorzaken

Puede hacer esto implementando un método de extensión a su tipo de enumeración definido:

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

Esto simplifica la obtención del valor int del valor de enumeración actual:

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

or

int value = Question.Role.getNumberValue();

Respondido el 08 de diciembre de 19 a las 16:12

Bronek, lo que hizo fue inventar una sintaxis poco informativa a través de un método de extensión (no genérico por cierto) que en realidad tarda más en escribir. No veo cómo es mejor que la solución original de Tetraneutron. No hagamos de esto un chat, la ayuda siempre es bienvenida en stackoverflow y todos los que están aquí están aquí para ayudar. Por favor, tomen mi comentario como una crítica constructiva. - benjamin grünbaum

Benjamin, en primer lugar, ¿por qué eliminaste mi comentario? No entiendo tus decisiones, tal vez alguien más de la comunidad estaría de acuerdo con mi comentario. En segundo lugar, mi solución envuelve el de Tetraneutron y con precisión es más fácil y menos escrito porque IntelliSense sugiere el método de extensión. Entonces creo que su decisión no es imparcial y representativa. Veo muchas respuestas similares en Stack y está bien. De todos modos, uso mi solución y tal vez algunas personas elegirían mi solución en el futuro, pero Estos puntos negativos hacen que sea más difícil de encontrar. Sobre todo, es correcto y no copia. - Bronek

@Bronek Si no me hace ping, no tengo ninguna indicación de que haya respondido. yo hice no elimine su comentario. No tengo la capacidad o no quiero hacerlo. Es probable que haya aparecido un mod y lo haya eliminado; puedes marcarlo para que preste atención al moderador y preguntar por qué, o mejor aún, preguntar en Desbordamiento de metastack. Tengo una opinión sobre su solución desde el punto de vista de la programación que está perfectamente en mi derecho; para esto son los comentarios para empezar, no es necesario que lo tome como algo personal. - benjamin grünbaum

Utilice un método de extensión en su lugar:

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

Y el uso es un poco más bonito:

var intValue = Question.Role.IntValue();

Respondido el 08 de diciembre de 19 a las 17:12

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

Respondido el 08 de diciembre de 19 a las 17:12

Una explicación del código de muestra estaría en orden (por editando tu respuesta, no aquí en los comentarios). - Pedro Mortensen

cero generalmente se reserva para el estado no establecido / desconocido en enumeraciones, inusual definirlo así - Beca Chad

Uso:

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

Resultará en value == 2.

Esto solo es cierto si la enumeración encaja dentro de un int.

Respondido el 08 de diciembre de 19 a las 17:12

Esto solo es cierto si la enumeración encaja dentro de un int por supuesto, como GetHashCode devuelve un número entero. - RB.

Dado que las enumeraciones se pueden declarar con múltiples tipos primitivos, un método de extensión genérico para convertir cualquier tipo de enumeración puede 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;

respondido 16 nov., 18:06

A continuación se muestra el método de extensión

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

respondido 16 nov., 18:06

La solución más fácil que se me ocurre es sobrecargar el Get(int) método como este:

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

dónde [modifiers] generalmente puede ser el mismo que para el Get(int) método. Si no puede editar el Questions class o por alguna razón no quiere, puede sobrecargar el método escribiendo una extensión:

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

Respondido el 08 de diciembre de 19 a las 16:12

Mi truco favorito con enumeraciones int o más pequeñas:

GetHashCode();

Para una enumeración

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

Esto,

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

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

salidas

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Cláusula de exención de responsabilidades:

No funciona para enumeraciones basadas en long.

Respondido el 08 de diciembre de 19 a las 17:12

Pruebe este en lugar de convertir enum a int:

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

Respondido el 14 de enero de 14 a las 20:01

El ejemplo que me gustaría sugerir "para obtener un valor 'int' de una enumeración" es

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

int answer = (int)Sample.Book;

Ahora la respuesta será 1.

Respondido el 08 de diciembre de 19 a las 17:12

Uso:

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

Respondido el 08 de diciembre de 19 a las 17:12

Deberías haber usado Tipo Casting como podemos usar en cualquier otro idioma.

Si enum es así

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

Y necesitas lanzar a un int, entonces haz esto-

Question q = Question.Role;
.............
.............
int something = (int) q;

Re-

En C #, hay dos tipos de conversión:

  • Casting implícito (automáticamente) - convertir un tipo más pequeño en un tamaño de letra más grande como-

char -> int -> long -> float -> double

  • Casting explícito (a mano) - convertir un tipo de letra más grande en un tipo de tamaño más pequeño como-

double -> float -> long -> int -> char

Se puede encontrar más en aquí.

Respondido el 23 de Septiembre de 20 a las 07:09

En Visual Basic, debería ser:

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

Private value As Integer = CInt(Question.Role)

Respondido el 08 de diciembre de 19 a las 17:12

La pregunta es para C #. - Control S

El título dice "Obtener valor int de la enumeración en C #". - Pedro Mortensen

le dará una lista con todos los valores enteros de la enumeración:

Lista enumValues ​​= Enum.GetValues ​​(typeof (EnumClass)). Cast (). ToList ();

Respondido el 12 de enero de 21 a las 02:01

Se me ocurrió este método de extensión que incluye las funciones del idioma actual. Al usar dynamic, no necesito hacer de esto un método genérico y especificar el tipo que mantiene la invocación más simple y 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;
    }

Respondido el 08 de diciembre de 19 a las 17:12

por favor no, podría hacer todo esto en una línea Convert.Changetype (e, e.GetTypeCode ()) y recuperar un objeto, sin necesidad de dinámica o un método de extensión - Beca Chad

No estaré de acuerdo con el uso de Convert. Usar un yeso sería más fácil. Mi intención era poder convertir cualquier enumeración a su valor sin usar un elenco. Esto permite cambiar el tipo de enumeración sin tener que cambiar todas las conversiones asociadas, pero ¿cuándo sucede esto? El método de extensión funciona correctamente. Sin embargo, tengo un problema con él porque, dado que es dinámico, el compilador no puede escribir check (aparentemente para toda la declaración), lo que significa que la verificación de tipos ocurre cuando se ejecuta, no es una buena solución. Creo que volveré a los yesos. - Jeff

No dije que lo use sobre la transmisión, solo que este código no tiene sentido y no logra nada, en realidad empeora el problema. Recomendaría eliminar esta solución. Beca Chad

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.