¿Cómo puedo convertir int a enum?

¿Cómo puede un int ser lanzado a un enum C ª#?

preguntado el 27 de agosto de 08 a las 01:08

30 Respuestas

Desde un int:

YourEnum foo = (YourEnum)yourInt;

De una cadena:

YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString);

// The foo.ToString().Contains(",") check is necessary for enumerations marked with an [Flags] attribute
if (!Enum.IsDefined(typeof(YourEnum), foo) && !foo.ToString().Contains(","))
{
    throw new InvalidOperationException($"{yourString} is not an underlying value of the YourEnum enumeration.")
}

Actualizar:

Desde el número también puede

YourEnum foo = (YourEnum)Enum.ToObject(typeof(YourEnum) , yourInt);

Respondido 17 ago 20, 20:08

@FlySwat, ¿y si YourEnum es dinámico y solo se conocerá en tiempo de ejecución, y lo que quiero es convertir a Enum? - Shimmy Weitzhandler

Tenga en cuenta que Enum.Parse NO funcionará si su código está ofuscado. En el tiempo de ejecución después de la ofuscación, la cadena se compara con los nombres de las enumeraciones y, en este punto, los nombres de las enumeraciones no son los que esperaría que fueran. Como resultado, su análisis fallará donde tuvo éxito antes. - jropella

TENER CUIDADO Si usa la sintaxis "de una cadena" anterior y pasa una cadena no válida que es un número (por ejemplo, "2342342", asumiendo que no es un valor de su enumeración), ¡realmente lo permitirá sin arrojar un error! Su enumeración tendrá ese valor (2342342) aunque no sea una opción válida en la enumeración en sí. - Joe fresco

Creo que esta respuesta está un poco anticuada ahora. Para cuerdas, realmente deberías usar var result = Enum.TryParse(yourString, out yourEnum) hoy en día (y verificando el resultado para determinar si la conversión falló). - justin t conroy

También es posible tener Enum.Parse no distingue entre mayúsculas y minúsculas añadiendo un true valor del parámetro a la llamada: YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString, true); - Erik Schierboom

Solo échalo:

MyEnum e = (MyEnum)3;

Puede verificar si está dentro del rango usando Enum.IsDefined:

if (Enum.IsDefined(typeof(MyEnum), 3)) { ... }

Respondido 27 ago 08, 05:08

Tenga en cuenta que no puede usar Enum.IsDefined si usa el atributo Flags y el valor es una combinación de banderas, por ejemplo: Keys.L | Keys.Control - destruir

Con respecto a Enum.IsDefined, tenga en cuenta que puede ser peligroso: msdn.microsoft.com/en-us/library/ms229025(VS.90).aspx - adrian

Prefiero esta definición: "Devuelve una indicación de si existe una constante con un valor especificado en una enumeración especificada" del MSDN - Papilla

... Porque tu definición puede ser engañosa, porque estás diciendo: "... comprueba si está dentro del alcance ..." lo que implica dentro de un rango de números con límites iniciales y finales ... - Papilla

@ mac9416 He intentado dar un ejemplo sucinto en gist.github.com/alowdon/f7354cda97bac70b44e1c04bc0991bcc - básicamente usando IsDefined para verificar los valores de entrada, se deja vulnerable a que las personas agreguen nuevos valores de enumeración más adelante, lo que IsDefined check (ya que el nuevo valor existe en el nuevo código), pero es posible que no funcione con el código original que escribió. Por lo tanto, es más seguro especificar explícitamente los valores de enumeración que su código puede manejar. - adrian

Alternativamente, use un método de extensión en lugar de una sola línea:

public static T ToEnum<T>(this string enumString)
{
    return (T) Enum.Parse(typeof (T), enumString);
}

Uso:

Color colorEnum = "Red".ToEnum<Color>();

OR

string color = "Red";
var colorEnum = color.ToEnum<Color>();

Respondido el 07 de enero de 16 a las 20:01

Para procesar la entrada del usuario, probablemente sea una buena idea llamar a la sobrecarga de Enum.Parse, que le permite especificar que la comparación NO distinga entre mayúsculas y minúsculas (es decir, un usuario que escriba "rojo" (minúsculas) bloqueará el código anterior sin este cambio .) - BrainSlugs83

Práctico, pero la pregunta se refiere específicamente a ints. - Jurado

esto también funciona si la cadena es un número entero, por ejemplo, "2" - VerdadDe42

Esto arrojará una excepción si enumString es nulo (ayer tuvo un problema similar). Considere usar TryParse en lugar de Parse. TryParse también comprobará si T es un tipo de enumeración - Justin

Este tipo de método de extensión en System.String parece contaminación del espacio de nombres - Sr. Anderson

Creo que para obtener una respuesta completa, la gente tiene que saber cómo funcionan las enumeraciones internamente en .NET.

Como funcionan las cosas

Una enumeración en .NET es una estructura que asigna un conjunto de valores (campos) a un tipo básico (el valor predeterminado es int). Sin embargo, en realidad puede elegir el tipo integral al que se asigna su enumeración:

public enum Foo : short

En este caso, la enumeración se asigna a la short tipo de datos, lo que significa que se almacenará en la memoria como un corto y se comportará como un corto cuando lo transmita y use.

Si lo mira desde el punto de vista de IL, una enumeración (normal, int) se ve así:

.class public auto ansi serializable sealed BarFlag extends System.Enum
{
    .custom instance void System.FlagsAttribute::.ctor()
    .custom instance void ComVisibleAttribute::.ctor(bool) = { bool(true) }

    .field public static literal valuetype BarFlag AllFlags = int32(0x3fff)
    .field public static literal valuetype BarFlag Foo1 = int32(1)
    .field public static literal valuetype BarFlag Foo2 = int32(0x2000)

    // and so on for all flags or enum values

    .field public specialname rtspecialname int32 value__
}

Lo que debería llamar su atención aquí es que el value__ se almacena por separado de los valores de enumeración. En el caso de la enumeración Foo arriba, el tipo de value__ es int16. Esto básicamente significa que puede almacenar lo que quiera en una enumeración, siempre que los tipos coincidan.

En este punto me gustaría señalar que System.Enum es un tipo de valor, lo que básicamente significa que BarFlag ocupará 4 bytes en la memoria y Foo ocupará 2, por ejemplo, el tamaño del tipo subyacente (en realidad es más complicado que eso, pero bueno ...).

La respuesta

Entonces, si tiene un número entero que desea asignar a una enumeración, el tiempo de ejecución solo tiene que hacer 2 cosas: copiar los 4 bytes y nombrarlo de otra manera (el nombre de la enumeración). La copia es implícita porque los datos se almacenan como tipo de valor; esto básicamente significa que si usa código no administrado, simplemente puede intercambiar enumeraciones y enteros sin copiar datos.

Para que sea seguro, creo que es una buena práctica saber que los tipos subyacentes son los mismos o implícitamente convertibles y para asegurarse de que existan los valores de enumeración (¡no están marcados por defecto!).

Para ver cómo funciona esto, pruebe el siguiente código:

public enum MyEnum : int
{
    Foo = 1,
    Bar = 2,
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)5;
    var e2 = (MyEnum)6;

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}

Tenga en cuenta que la transmisión a e2 ¡también funciona! Desde la perspectiva del compilador anterior, esto tiene sentido: el value__ El campo simplemente se llena con 5 o 6 y cuando Console.WriteLine llamadas ToString(), el nombre de e1 se resuelve mientras el nombre de e2 no es.

Si eso no es lo que pretendías, usa Enum.IsDefined(typeof(MyEnum), 6) para comprobar si el valor que está enviando se corresponde con una enumeración definida.

También tenga en cuenta que soy explícito sobre el tipo subyacente de la enumeración, aunque el compilador realmente comprueba esto. Estoy haciendo esto para asegurarme de no encontrarme con sorpresas en el futuro. Para ver estas sorpresas en acción, puede usar el siguiente código (de hecho, he visto que esto sucede mucho en el código de la base de datos):

public enum MyEnum : short
{
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)32769; // will not compile, out of bounds for a short

    object o = 5;
    var e2 = (MyEnum)o;     // will throw at runtime, because o is of type int

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}

Respondido 03 Abr '14, 08:04

Me doy cuenta de que esta es una publicación antigua, pero ¿cómo se obtiene este nivel de conocimiento en c #? ¿Es esto por leer la especificación de C #? - Rolan

@Rolan A veces deseo que más personas pregunten eso. :-) Para ser honesto, realmente no lo sé; Intento entender cómo funcionan las cosas y obtener información donde sea que pueda. Leí el estándar C #, pero también descompilo código regularmente con Reflector (incluso miro mucho el código del ensamblador x86) y hago toneladas de pequeños experimentos. Además, conocer otros idiomas ayuda en este caso; He estado haciendo CS durante unos 30 años y, en algún momento, ciertas cosas se vuelven `` lógicas '', p. Ej. una enumeración debe tipos integrales, porque de lo contrario la interoperabilidad se romperá (o su rendimiento se irá por el desagüe). - atlasto

Creo que la clave para hacer ingeniería de software correctamente es saber cómo funcionan las cosas. Para mí, eso significa que si escribes un fragmento de código, sabes cómo se traduce aproximadamente a f.ex. operaciones del procesador y recuperaciones / escrituras de memoria. Si pregunta cómo llegar a ese nivel, le sugiero que cree un montón de casos de prueba pequeños, haciéndolos más difíciles a medida que avanza, intente predecir el resultado cada vez y pruébelos después (incluida la descompilación, etc.). Después de averiguar todos los detalles y todas las características, puede verificar si lo hizo bien en el estándar (aburrido). Al menos, ese sería mi enfoque. - atlasto

Fantástica respuesta, gracias! En su última muestra de código, arroja una excepción en tiempo de ejecución porque o es un objeto. Puede convertir una variable int a un corto siempre que se encuentre dentro del rango corto. - Pensamientos grávidos

@gravidThoughts Gracias. En realidad, es una operación de unboxing, por lo que no realizará conversiones implícitas como las que describe. La conversión a veces es confusa en C # si no conoce los detalles ... De todos modos, porque int != short, arrojará (el desempaquetado falla). Si lo haces object o = (short)5;, funcionará, porque entonces los tipos coincidirán. No se trata del rango, realmente se trata del tipo. - atlasto

Tome el siguiente ejemplo:

int one = 1;
MyEnum e = (MyEnum)one;

Respondido el 25 de diciembre de 16 a las 09:12

Estoy usando este fragmento de código para convertir int a mi enumeración:

if (typeof(YourEnum).IsEnumDefined(valueToCast)) return (YourEnum)valueToCast;
else { //handle it here, if its not defined }

Encuentro que es la mejor solución.

Respondido 21 Oct 11, 11:10

Esto es bueno. Me sorprendió que no hubiera una excepción al lanzar un valor no válido a una enumeración respaldada por int. - orión elenzil

En realidad, esto no es tan diferente de la respuesta mejor calificada. Esa respuesta también analiza el uso de Enum.IsDefined después de haber lanzado la cadena al tipo Enum. Entonces, incluso si la cadena se lanzó sin errores, Enum.IsDefined aún la detectará: Don Cheadle

A continuación se muestra una buena clase de utilidad para Enums

public static class EnumHelper
{
    public static int[] ToIntArray<T>(T[] value)
    {
        int[] result = new int[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = Convert.ToInt32(value[i]);
        return result;
    }

    public static T[] FromIntArray<T>(int[] value) 
    {
        T[] result = new T[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = (T)Enum.ToObject(typeof(T),value[i]);
        return result;
    }


    internal static T Parse<T>(string value, T defaultValue)
    {
        if (Enum.IsDefined(typeof(T), value))
            return (T) Enum.Parse(typeof (T), value);

        int num;
        if(int.TryParse(value,out num))
        {
            if (Enum.IsDefined(typeof(T), num))
                return (T)Enum.ToObject(typeof(T), num);
        }

        return defaultValue;
    }
}

Respondido el 07 de Septiembre de 10 a las 05:09

Para valores numéricos, esto es más seguro ya que devolverá un objeto sin importar qué:

public static class EnumEx
{
    static public bool TryConvert<T>(int value, out T result)
    {
        result = default(T);
        bool success = Enum.IsDefined(typeof(T), value);
        if (success)
        {
            result = (T)Enum.ToObject(typeof(T), value);
        }
        return success;
    }
}

Respondido el 07 de enero de 16 a las 20:01

Devuelve predeterminado (T) cuando no está definido. ¿Cómo ayuda eso a identificar los indefinidos? - Ε Ã И І И О

Si estás listo para la 4.0 .NET Framework, hay un nuevo Enum.TryParse () función que es muy útil y funciona bien con el atributo [Flags]. Ver Método Enum.TryParse (String, TEnum%)

Respondido 31 ago 12, 21:08

Eso es útil cuando se convierte de una cadena. Pero no al convertir de un int. - CódigosInChaos

Si tiene un número entero que actúa como una máscara de bits y podría representar uno o más valores en una enumeración [Flags], puede usar este código para analizar los valores de las banderas individuales en una lista:

for (var flagIterator = 0; flagIterator < 32; flagIterator++)
{
    // Determine the bit value (1,2,4,...,Int32.MinValue)
    int bitValue = 1 << flagIterator;

    // Check to see if the current flag exists in the bit mask
    if ((intValue & bitValue) != 0)
    {
        // If the current flag exists in the enumeration, then we can add that value to the list
        // if the enumeration has that flag defined
        if (Enum.IsDefined(typeof(MyEnum), bitValue))
            Console.WriteLine((MyEnum)bitValue);
    }
}

Tenga en cuenta que esto supone que el tipo subyacente de enum es un entero de 32 bits con signo. Si fuera un tipo numérico diferente, tendría que cambiar el 32 codificado para reflejar los bits en ese tipo (o derivarlo programáticamente usando Enum.GetUnderlyingType())

Respondido el 02 de enero de 19 a las 15:01

A veces tienes un objeto al MyEnum tipo. Como

var MyEnumType = typeof(MyEnum);

Entonces:

Enum.ToObject(typeof(MyEnum), 3)

Respondido 20 Oct 20, 06:10

Este es un método de conversión seguro consciente de la enumeración de banderas:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: Enum
{
  var enumType = typeof (T);
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}

respondido 12 nov., 18:18

Esto ahora se puede mejorar con C # 7.3 restringiendo a Enum en lugar de struct, lo que significa que no tenemos que depender de la verificación del tiempo de ejecución. - Scott

enter image description here

Para convertir una cadena a ENUM o int a ENUM constante, necesitamos usar la función Enum.Parse. Aquí hay un video de youtube https://www.youtube.com/watch?v=4nhx4VwdRDk que en realidad demuestran con una cadena y lo mismo se aplica para int.

El código es como se muestra a continuación, donde "rojo" es la cadena y "MyColors" es el color ENUM que tiene las constantes de color.

MyColors EnumColors = (MyColors)Enum.Parse(typeof(MyColors), "Red");

Respondido 05 Feb 14, 12:02

Un poco alejándome de la pregunta original, pero encontré una respuesta a la pregunta de Stack Overflow Obtener valor int de enum útil. Crea una clase estática con public const int propiedades, lo que le permite recopilar fácilmente un montón de int constantes, y luego no tener que lanzarlas a int al usarlos.

public static class Question
{
    public static readonly int Role = 2;
    public static readonly int ProjectFunding = 3;
    public static readonly int TotalEmployee = 4;
    public static readonly int NumberOfServers = 5;
    public static readonly int TopBusinessConcern = 6;
}

Obviamente, se perderá parte de la funcionalidad del tipo de enumeración, pero para almacenar un montón de constantes de identificación de base de datos, parece una solución bastante ordenada.

contestado el 23 de mayo de 17 a las 11:05

enums reemplazó el uso de constantes enteras como esta, ya que proporcionan más seguridad de tipos - Paul Richards

Paul, este es un método para recopilar constantes int relacionadas (por ejemplo, constantes de ID de base de datos) para que se puedan usar directamente sin tener que convertirlas en int cada vez que se usan. Su tipo is integer, no por ejemplo, DatabaseIdsEnum. - Ted

Hay al menos una situación que he encontrado en la que la seguridad del tipo de enumeración se puede omitir involuntariamente. - Thierry

Pero las enumeraciones también se aseguran de que todos los valores sean únicos, algo de lo que este enfoque también carece: derHugo

Esto analiza enteros o cadenas a una enumeración de destino con coincidencia parcial en .NET 4.0 usando genéricos como en Clase de utilidad de Tawani. Lo estoy usando para convertir variables de cambio de línea de comandos que pueden estar incompletas. Dado que una enumeración no puede ser nula, lógicamente debe proporcionar un valor predeterminado. Se puede llamar así:

var result = EnumParser<MyEnum>.Parse(valueToParse, MyEnum.FirstValue);

Aquí está el código:

using System;

public class EnumParser<T> where T : struct
{
    public static T Parse(int toParse, T defaultVal)
    {
        return Parse(toParse + "", defaultVal);
    }
    public static T Parse(string toParse, T defaultVal)
    {
        T enumVal = defaultVal;
        if (defaultVal is Enum && !String.IsNullOrEmpty(toParse))
        {
            int index;
            if (int.TryParse(toParse, out index))
            {
                Enum.TryParse(index + "", out enumVal);
            }
            else
            {
                if (!Enum.TryParse<T>(toParse + "", true, out enumVal))
                {
                    MatchPartialName(toParse, ref enumVal);
                }
            }
        }
        return enumVal;
    }

    public static void MatchPartialName(string toParse, ref T enumVal)
    {
        foreach (string member in enumVal.GetType().GetEnumNames())
        {
            if (member.ToLower().Contains(toParse.ToLower()))
            {
                if (Enum.TryParse<T>(member + "", out enumVal))
                {
                    break;
                }
            }
        }
    }
}

FYI: La pregunta era sobre números enteros, que nadie mencionó también convertirá explícitamente en Enum.TryParse ()

Respondido 13 Jul 20, 01:07

De una cadena: (Enum.Parse está desactualizado, use Enum.TryParse)

enum Importance
{}

Importance importance;

if (Enum.TryParse(value, out importance))
{
}

respondido 21 nov., 14:00

La pregunta se refiere específicamente a los números enteros. - Jurado

Will Yu, por favor, edite su respuesta para que todos sepan Enum. TryParse funcionará en una cadena del valor o el nombre de la enumeración (no pude resistir) - Jeremy Weir

Jeremy, Weir está trabajando en eso (tampoco pudo resistirse). - huysentruitw

El siguiente es un método de extensión ligeramente mejor:

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 13 Jul 20, 01:07

esto es en realidad mucho mejor porque si el valor int no es una entrada definida en la enumeración, puede usar una instrucción else para establecer enumString en un valor predeterminado. Gracias - NDUF

Debería incorporar algún tipo de relajación que coincida con el tipo para ser más robusto.

public static T ToEnum<T>(dynamic value)
{
    if (value == null)
    {
        // default value of an enum is the object that corresponds to
        // the default value of its underlying type
        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table
        value = Activator.CreateInstance(Enum.GetUnderlyingType(typeof(T)));
    }
    else if (value is string name)
    {
        return (T)Enum.Parse(typeof(T), name);
    }

    return (T)Enum.ToObject(typeof(T),
             Convert.ChangeType(value, Enum.GetUnderlyingType(typeof(T))));
}

Caso de prueba

[Flags]
public enum A : uint
{
    None  = 0, 
    X     = 1 < 0,
    Y     = 1 < 1
}

static void Main(string[] args)
{
    var value = EnumHelper.ToEnum<A>(7m);
    var x = value.HasFlag(A.X); // true
    var y = value.HasFlag(A.Y); // true

    var value2 = EnumHelper.ToEnum<A>("X");

    var value3 = EnumHelper.ToEnum<A>(null);

    Console.ReadKey();
}

Respondido el 07 de Septiembre de 19 a las 19:09

Esta es una buena respuesta. ¡Es una pena que esté tan abajo en la página en este momento! - mikebeaton

En mi caso, necesitaba devolver la enumeración de un servicio WCF. También necesitaba un nombre descriptivo, no solo el enum.ToString ().

Aquí está mi clase WCF.

[DataContract]
public class EnumMember
{
    [DataMember]
    public string Description { get; set; }

    [DataMember]
    public int Value { get; set; }

    public static List<EnumMember> ConvertToList<T>()
    {
        Type type = typeof(T);

        if (!type.IsEnum)
        {
            throw new ArgumentException("T must be of type enumeration.");
        }

        var members = new List<EnumMember>();

        foreach (string item in System.Enum.GetNames(type))
        {
            var enumType = System.Enum.Parse(type, item);

            members.Add(
                new EnumMember() { Description = enumType.GetDescriptionValue(), Value = ((IConvertible)enumType).ToInt32(null) });
        }

        return members;
    }
}

Aquí está el método de extensión que obtiene la descripción de la enumeración.

    public static string GetDescriptionValue<T>(this T source)
    {
        FieldInfo fileInfo = source.GetType().GetField(source.ToString());
        DescriptionAttribute[] attributes = (DescriptionAttribute[])fileInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);            

        if (attributes != null && attributes.Length > 0)
        {
            return attributes[0].Description;
        }
        else
        {
            return source.ToString();
        }
    }

Implementación:

return EnumMember.ConvertToList<YourType>();

Respondido 02 Jul 14, 15:07

Aquí hay un método de extensión que arroja Int32 a Enum.

Respeta los indicadores bit a bit incluso cuando el valor es superior al máximo posible. Por ejemplo, si tiene una enumeración con posibilidades 1, 2y 4, pero el int es 9, entiende que como 1 en ausencia de un 8. Esto le permite realizar actualizaciones de datos antes de las actualizaciones de código.

   public static TEnum ToEnum<TEnum>(this int val) where TEnum : struct, IComparable, IFormattable, IConvertible
    {
        if (!typeof(TEnum).IsEnum)
        {
            return default(TEnum);
        }

        if (Enum.IsDefined(typeof(TEnum), val))
        {//if a straightforward single value, return that
            return (TEnum)Enum.ToObject(typeof(TEnum), val);
        }

        var candidates = Enum
            .GetValues(typeof(TEnum))
            .Cast<int>()
            .ToList();

        var isBitwise = candidates
            .Select((n, i) => {
                if (i < 2) return n == 0 || n == 1;
                return n / 2 == candidates[i - 1];
            })
            .All(y => y);

        var maxPossible = candidates.Sum();

        if (
            Enum.TryParse(val.ToString(), out TEnum asEnum)
            && (val <= maxPossible || !isBitwise)
        ){//if it can be parsed as a bitwise enum with multiple flags,
          //or is not bitwise, return the result of TryParse
            return asEnum;
        }

        //If the value is higher than all possible combinations,
        //remove the high imaginary values not accounted for in the enum
        var excess = Enumerable
            .Range(0, 32)
            .Select(n => (int)Math.Pow(2, n))
            .Where(n => n <= val && n > 0 && !candidates.Contains(n))
            .Sum();

        return Enum.TryParse((val - excess).ToString(), out asEnum) ? asEnum : default(TEnum);
    }

Respondido 22 Feb 19, 01:02

Diferentes formas de emitir para y de Enum

enum orientation : byte
{
 north = 1,
 south = 2,
 east = 3,
 west = 4
}

class Program
{
  static void Main(string[] args)
  {
    orientation myDirection = orientation.north;
    Console.WriteLine(“myDirection = {0}”, myDirection); //output myDirection =north
    Console.WriteLine((byte)myDirection); //output 1

    string strDir = Convert.ToString(myDirection);
        Console.WriteLine(strDir); //output north

    string myString = “north”; //to convert string to Enum
    myDirection = (orientation)Enum.Parse(typeof(orientation),myString);


 }
}

Respondido el 08 de enero de 14 a las 15:01

Ya no sé de dónde obtengo la parte de esta extensión de enumeración, pero es de stackoverflow. ¡Lo siento por esto! Pero tomé este y lo modifiqué para enumeraciones con Flags. Para enumeraciones con banderas hice esto:

  public static class Enum<T> where T : struct
  {
     private static readonly IEnumerable<T> All = Enum.GetValues(typeof (T)).Cast<T>();
     private static readonly Dictionary<int, T> Values = All.ToDictionary(k => Convert.ToInt32(k));

     public static T? CastOrNull(int value)
     {
        T foundValue;
        if (Values.TryGetValue(value, out foundValue))
        {
           return foundValue;
        }

        // For enums with Flags-Attribut.
        try
        {
           bool isFlag = typeof(T).GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
           if (isFlag)
           {
              int existingIntValue = 0;

              foreach (T t in Enum.GetValues(typeof(T)))
              {
                 if ((value & Convert.ToInt32(t)) > 0)
                 {
                    existingIntValue |= Convert.ToInt32(t);
                 }
              }
              if (existingIntValue == 0)
              {
                 return null;
              }

              return (T)(Enum.Parse(typeof(T), existingIntValue.ToString(), true));
           }
        }
        catch (Exception)
        {
           return null;
        }
        return null;
     }
  }

Ejemplo:

[Flags]
public enum PetType
{
  None = 0, Dog = 1, Cat = 2, Fish = 4, Bird = 8, Reptile = 16, Other = 32
};

integer values 
1=Dog;
13= Dog | Fish | Bird;
96= Other;
128= Null;

Respondido el 07 de enero de 16 a las 11:01

Puede ayudarlo a convertir cualquier dato de entrada al deseado por el usuario enumerar. Suponga que tiene una enumeración como la siguiente que, por defecto, int. Por favor agregue un Predeterminado valor al principio de su enumeración. Que se usa en el método de ayuda cuando no se encuentra ninguna coincidencia con el valor de entrada.

public enum FriendType  
{
    Default,
    Audio,
    Video,
    Image
}

public static class EnumHelper<T>
{
    public static T ConvertToEnum(dynamic value)
    {
        var result = default(T);
        var tempType = 0;

        //see Note below
        if (value != null &&
            int.TryParse(value.ToString(), out  tempType) && 
            Enum.IsDefined(typeof(T), tempType))
        {
            result = (T)Enum.ToObject(typeof(T), tempType); 
        }
        return result;
    }
}

NB: Aquí trato de analizar el valor en int, porque enum es por defecto int Si define una enumeración como esta, que es byte tipo.

public enum MediaType : byte
{
    Default,
    Audio,
    Video,
    Image
} 

Debe cambiar el análisis sintáctico en el método auxiliar de

int.TryParse(value.ToString(), out  tempType)

a

byte.TryParse(value.ToString(), out tempType)

Verifico mi método para las siguientes entradas

EnumHelper<FriendType>.ConvertToEnum(null);
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("-1");
EnumHelper<FriendType>.ConvertToEnum("6");
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("2");
EnumHelper<FriendType>.ConvertToEnum(-1);
EnumHelper<FriendType>.ConvertToEnum(0);
EnumHelper<FriendType>.ConvertToEnum(1);
EnumHelper<FriendType>.ConvertToEnum(9);

lo siento por mi Inglés

respondido 17 nov., 16:12

La forma fácil y clara de convertir un int a enum en C #:

public class Program
{
    public enum Color : int
    {
        Blue   = 0,
        Black  = 1,
        Green  = 2,
        Gray   = 3,
        Yellow = 4
    }

    public static void Main(string[] args)
    {
        // From string
        Console.WriteLine((Color) Enum.Parse(typeof(Color), "Green"));

        // From int
        Console.WriteLine((Color)2);

        // From number you can also
        Console.WriteLine((Color)Enum.ToObject(typeof(Color), 2));
    }
}

Respondido 13 Jul 20, 01:07

Simplemente usa Conversión explícita Cast int a enum o enum a int

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine((int)Number.three); //Output=3

        Console.WriteLine((Number)3);// Outout three
        Console.Read();
    }

    public enum Number
    {
        Zero = 0,
        One = 1,
        Two = 2,
        three = 3
    }
}

Respondido 05 Abr '20, 10:04

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace SamplePrograme
{
    public class Program
    {
        public enum Suit : int
        {
            Spades = 0,
            Hearts = 1,
            Clubs = 2,
            Diamonds = 3
        }

        public static void Main(string[] args)
        {
            //from string
            Console.WriteLine((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));
        }
    }
}

Respondido 17 Oct 19, 08:10

Simplemente haz como a continuación:

int intToCast = 1;
TargetEnum f = (TargetEnum) intToCast ;

Para asegurarse de que solo transmite los valores correctos y que puede lanzar una excepción de lo contrario:

int intToCast = 1;
if (Enum.IsDefined(typeof(TargetEnum), intToCast ))
{
    TargetEnum target = (TargetEnum)intToCast ;
}
else
{
   // Throw your exception.
}

Tenga en cuenta que usar IsDefined es costoso e incluso más que solo convertir, por lo que depende de su implementación decidir si usarlo o no.

Respondido 27 Jul 19, 08:07

Simple, puedes convertir int a enum

 public enum DaysOfWeeks
    {
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7,
    } 

    var day= (DaysOfWeeks)5;
    Console.WriteLine("Day is : {0}", day);
    Console.ReadLine();

Respondido 14 Jul 20, 07:07

Si el elenco funcionara, no podría almacenarlo como int. - Ap.

Por favor, intente entender int to Enum, creo que la respuesta anterior es para ayudarlo. - Inam Abbas

Puede utilizar un método de extensión.

public static class Extensions
{

    public static T ToEnum<T>(this string data) where T : struct
    {
        if (!Enum.TryParse(data, true, out T enumVariable))
        {
            if (Enum.IsDefined(typeof(T), enumVariable))
            {
                return enumVariable;
            }
        }

        return default;
    }

    public static T ToEnum<T>(this int data) where T : struct
    {
        return (T)Enum.ToObject(typeof(T), data);
    }
}

Úselo como el siguiente código:

enumeración:

public enum DaysOfWeeks
{
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7,
}

Uso:

 string Monday = "Mon";
 int Wednesday = 3;
 var Mon = Monday.ToEnum<DaysOfWeeks>();
 var Wed = Wednesday.ToEnum<DaysOfWeeks>();

Respondido 13 Jul 20, 01:07

Necesito dos instrucciones:

YourEnum possibleEnum = (YourEnum)value; // There isn't any guarantee that it is part of the enum
if (Enum.IsDefined(typeof(YourEnum), possibleEnum))
{
    // Value exists in YourEnum
}

Respondido 13 Jul 20, 01:07

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