Obtenga el valor int de enum en C #


1826

Tengo una clase llamada Questions(plural). En esta clase hay una enumeración llamada Question(singular) que se ve así.

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

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


31
Por el contrario: cast-int-to-enum-in-c-sharp .
nawfal

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

Respuestas:


2355

Solo eche la enumeración, por ejemplo

int something = (int) Question.Role;

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

Sin embargo, como señala cecilphillip , las enumeraciones pueden tener diferentes tipos subyacentes. Si una enumeración se declara como a uint, longo ulong, se debe convertir al tipo de enumeración; por ejemplo para

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

Deberías usar

long something = (long)StarsInMilkyWay.Wolf424B;

23
@ Harry no es cierto. Puede crear la enumeración sin lanzar, no es obligatorio. y solo asigno un número en casos especiales, la mayoría de las veces, lo dejo como valor predeterminado. pero puedes hacer enum Test { Item = 1 }y ver que 1 == (int)Test.Itemes igual.
Jaider

33
@Jaider ¡ (int)Test.ItemEso es un elenco! () es el operador de conversión explícito.
Sinthia V

48
@Sinthia V dijo que puedes crearlo sin lanzar, lo cual es correcto
Paul Ridgway

77
¡Si el tipo subyacente para enum Questionno fuera intpero longeste reparto truncará Roleel valor integral!
Quaylar

1
Cuando acepta un Enumcomo parámetro, sabe que solo puede obtener un número fijo de valores integrales posibles. Por otro lado, si toma simplemente un int, entonces debe validar si intestá 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

307

Desde Enums puede ser cualquier tipo integral ( byte, int, short, etc.), una forma más sólida para obtener el valor integral subyacente de la enumeración sería la de hacer uso del GetTypeCodemétodo en conjunción con la Convertclase:

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.


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

1
¿Cómo modificaría esto para imprimir el valor hexadecimal de lado? Este ejemplo muestra el valor decimal. El problema es que vares de tipo object, por lo que debe desempaquetarlo y se vuelve más complicado de lo que me gustaría.
Mark Lakata

2
Creo que debería cambiar el ejemplo de object val = Convert...etcla varen su ejemplo será siempre object.
Mesh

2
@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) estaban asignando los enteros de manera diferente a cada valor. Eso significaba que los objetos serializados en una sola 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 autogenerados fueran los mismos cuando se construían en diferentes versiones de framework.
NickG

44
@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 se eliminen en uno. Como tal, nuestros estándares de codificación ahora requieren que las 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 que causan corrupción de datos. Recomiendo encarecidamente a cualquiera que especifique todos los enteros de Enum explícitamente. Esto es extremadamente importante si se correlacionan con valores almacenados externamente (base de datos).
NickG

199

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 puede hacer referencia a él como Question.Role, y siempre se evalúa como into lo que sea que usted defina.


31
Lo usaría static readonly intporque las constantes se compilan en sus valores duros. Ver stackoverflow.com/a/755693/492
CAD bloke

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

12
@CADBloke, que es precisamente por lo que usarías consty no static readonlyporque cada vez que comparas static readonlyestás haciendo una llamada a un método para obtener el valor de la variable, mientras que con una constestás comparando dos tipos de valores directamente.
blockloop

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

2
@Zack No lo expliqué muy bien, compilation limitationquiero decir que el valor está codificado cuando lo compila, por lo que cualquier cambio en ese valor requeriría que todos los ensamblajes que lo usan tengan que volver a compilarse. Me inclino a estar de acuerdo con usted sobre el uso porque cambiar los valores tendría implicaciones de largo alcance.
CAD bloke

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

Resultará en value == 2.


34
La pregunta variable temporal es innecesaria.
Gishu

1
Entonces, algo como esto Questions.Get (Convert.ToInt16 (Question.Applications))
jim

66
Simplemente puede lanzar en cualquier dirección; lo único que se debe 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, solo emite el valor: Questions.Get ((int) Question.Applications);
Guffa 03 de

1
@Gishu Se podría decir que es ... cuestionable. ;)
Felix D.

79

En una nota relacionada, si desea obtener el intvalor de System.Enum, dado eaquí:

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 simplemente feos. Prefiero la primera.


1
Sin embargo, el segundo es el más rápido.
Johan B

1
Como alguien que está acostumbrado a usar Mixins en el modding de Minecraft, el segundo parece ser el ganador obvio.
Sollace

40

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

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

15
Nitpick: esta enumeración ya es un int. Otras enumeraciones pueden ser de diferentes tipos: pruebe "enum SmallEnum: byte {A, B, C}"
mqp

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

33

Ejemplo:

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

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

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

o

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

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


66
¿Esto realmente compila?
Peter Mortensen el

¿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 Gonzalez el

@TimothyGonzalez realmente enumera simplemente contar 1 hasta si no especificas explícitamente su valor;)
derHugo

@derHugo que depende si asume que los valores numéricos son base 10 o base 2.
Timothy Gonzalez el

@TimothyGonzalez así que no hay mucho suponer ... acabo de señalar que, por defecto lo hacen simplemente contar hasta 1en intexcepto que defina explícitamente lo contrario
derHugo

28

Recientemente me he convertido 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 es cómo abordaría ahora 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 si necesita realizar diferentes acciones en función del valor de Question, puede poner la lógica en Questionsí misma (es decir, en el OO preferido moda) en lugar de poner muchas declaraciones de casos en todo el código para abordar cada escenario.


NB: la respuesta se actualizó el 27/04/2018 para utilizar las funciones de C # 6; es decir, expresiones de declaración y definiciones de cuerpo de expresión lambda. Ver historial de revisiones para el código original. Esto tiene el beneficio 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.


2
Supongo que es una compensación entre el reparto explícito y el código que tienes que escribir para evitarlo. Todavía me encanta la implementación, solo desearía que no fuera tan larga. +1
Lankymart

3
He usado varios tipos diferentes de clases estructuradas de manera similar a esto. Encuentro que funcionan de maravilla cuando intentan seguir la metodología de "no me dejen ser idiota más tarde".
James Haug

20

Si desea obtener un número entero para el valor enum que se almacena en una variable, para el cual sería el tipo 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 Geselecteerdes Talen.Nederlands. Si lo cambio y vuelvo a Talen.Portugeesllamar al método, el texto cambiará a 3.


3
codificación en holandés. Oh querido.
WiseStrawberry

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

16

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

14

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

Esto funciona muy bien para mi. Puede evitar el tipo de conversión en su API de esta manera, pero finalmente resulta en una operación de cambio de tipo. Este es un buen caso para programar a Roslyn para que el compilador haga un método GetValue <T> para usted.

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

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

Re "Tal vez me lo perdí, pero ¿alguien ha intentado un método de extensión genérico simple ?" : SixOThree dijo "Use un método de extensión en su lugar" y Bronek dijo "Puede hacer esto implementando un método de extensión a su tipo de enumeración definido" .
Peter Mortensen

13

Una forma más de hacerlo:

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

Resultará en:

Name: Role, Value: 2

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

... es una buena declaración.

Tienes que enviar el resultado a int así:

int Question = (int)QuestionType.Role

De lo contrario, el tipo sigue siendo QuestionType .

Este nivel de rigor es la forma 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 declararlo, 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.


11
int number = Question.Role.GetHashCode();

numberDebería tener el valor 2.


GetHashCode es una forma de obtener valor de la máscara común de Enum
ThanhLD, el

Tenga en cuenta que esto sólo es "legítimo" para bool*, byte, ushort, int, y uint**. GetHashCode para otros tipos modifica el valor, por ejemplo, hace algunos cambios de bits y xors. (* 1/0, ** lanzado a int por supuesto). Pero, en general, no haga esto a menos que sea su propio código privado.
AnorZaken

10

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

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

Esto simplifica obtener el valor int del valor enum actual:

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

o

int value = Question.Role.getNumberValue();

55
Bronek, lo que hiciste fue crear una sintaxis no informativa a través de un método de extensión (por cierto no genérico) que en realidad toma más tiempo para escribir. No veo cómo es mejor que la solución original de Tetraneutron. No permitamos que esto se convierta en un chat, la ayuda siempre es bienvenida en stackoverflow y todos los que están aquí están aquí para ayudar. Por favor tome mi comentario como crítica constructiva.
Benjamin Gruenbaum

2
Benjamin, antes que nada, ¿por qué borraste 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 la de Tetraneutron y con precisión es más fácil y menos escrito porque un IntelliSense sugiere el método de extensión. Por lo tanto, 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 haya algunas personas que elijan 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

3
@Bronek Si no me haces ping, no recibo ninguna indicación de que hayas respondido. Yo no eliminar tu comentario no tengo la capacidad o el deseo de hacerlo. Probablemente apareció un mod y lo eliminó; puede marcarlo para la atención del moderador y preguntar por qué o mejor aún: pregunte en Meta Stack Overflow . Tengo una opinión sobre su solución desde un punto de vista de programación que está perfectamente en mi derecho: para empezar, esto es lo que los comentarios son, no es necesario que lo tome como algo personal.
Benjamin Gruenbaum

8

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

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

palo - "10. (juegos de cartas) Cada uno de los juegos de un paquete de cartas se distingue por color y / o emblemas específicos, como las espadas, corazones, diamantes o mazas de naipes tradicionales anglos, hispanos y franceses".
Peter Mortensen

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

el cero generalmente está reservado para el estado no definido / desconocido en las enumeraciones, inusual para definirlo así
Chad Grant

6

Utilizar:

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

Resultará en value == 2 .

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


1
Esto solo es cierto si la enumeración encaja dentro de un, intpor supuesto, ya que GetHashCodedevuelve un entero.
RB.

5

Dado que las enumeraciones pueden declararse 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;

4

El siguiente es 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;
}

4

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

GetHashCode();

Por una enumeración

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

Esta,

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

Descargo de responsabilidad:

No funciona para enumeraciones basadas en mucho tiempo.


3

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

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

donde [modifiers]generalmente puede ser el mismo que para el Get(int)método. Si no puede editar la Questionsclase o por alguna razón no lo desea, 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);
    }
}

3

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.



2

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

2

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)

3
La pregunta es para C #.
Ctrl S

2
El título dice "Obtenga el valor int de enum en C #" .
Peter Mortensen

0

Se me ocurrió este método de extensión que incluye características de lenguaje actuales. Al usar Dynamic, no necesito hacer de este 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;
    }

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
Chad Grant

No estaré de acuerdo con el uso de Convertir. Solo usar un yeso sería más fácil. Mi intención era poder convertir cualquier enumeración a su valor sin usar un yeso. Esto permite cambiar el tipo de enumeración sin tener que cambiar todos los modelos asociados, pero ¿cuándo sucede esto? El método de extensión funciona correctamente. Sin embargo, tengo un problema con eso, ya que es dinámico, el compilador no puede escribir la verificación (aparentemente para toda la declaración), lo que significa que la verificación de tipo ocurre cuando se ejecuta, no es una buena solución. Creo que volveré a los moldes.
Jeff

1
No dije usarlo sobre el elenco, solo que este código no tiene sentido y no logra nada, en realidad empeora el problema. Recomendaría eliminar esta solución
Chad Grant
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.