recorrer - obtener id de un enum c#

Cómo obtener valor enum por cadena o int

Question

¿Cómo puedo obtener el valor de enumeración si tengo la cadena de enumeración o el valor de enum int? Por ejemplo: si tengo una enumeración de la siguiente manera:

public enum TestEnum
{
    Value1 = 1,
    Value2 = 2,
    Value3 = 3
}

y en alguna variable de cadena tengo el valor "value1" como sigue:

string str = "Value1" 

o en alguna variable int tengo el valor 2 como

int a = 2;

¿Cómo puedo obtener la instancia de enumeración? Quiero un método genérico donde pueda proporcionar la enumeración y mi cadena de entrada o valor int para obtener la instancia de enumeración.

Answer 1

A continuación se muestra el método en C # para obtener el valor de enumeración por cadena

    ///
    /// Method to get enumeration value from string value.
    ///
    ///
    ///

    public T GetEnumValue<T>(string str) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }
        T val = ((T[])Enum.GetValues(typeof(T)))[0];
        if (!string.IsNullOrEmpty(str))
        {
            foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
            {
                if (enumValue.ToString().ToUpper().Equals(str.ToUpper()))
                {
                    val = enumValue;
                    break;
                }
            }
        }

        return val;
    }

A continuación se muestra el método en C # para obtener el valor enum por int.

    ///
    /// Method to get enumeration value from int value.
    ///
    ///
    ///

    public T GetEnumValue<T>(int intValue) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }
        T val = ((T[])Enum.GetValues(typeof(T)))[0];

        foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
        {
            if (Convert.ToInt32(enumValue).Equals(intValue))
            {
                val = enumValue;
                break;
            }             
        }
        return val;
    }

Si tengo una enumeración de la siguiente manera:

public enum TestEnum
    {
        Value1 = 1,
        Value2 = 2,
        Value3 = 3
    }

entonces puedo hacer uso de los métodos anteriores como

TestEnum reqValue = GetEnumValue<TestEnum>("Value1");  // Output: Value1
TestEnum reqValue2 = GetEnumValue<TestEnum>(2);       // OutPut: Value2

Espero que esto ayude.

Answer 2

Creo que olvidaste la definición de tipo genérico:

public T GetEnumValue<T>(int intValue) where T : struct, IConvertible // <T> added

y puedes mejorarlo para que sea más conveniente como, por ejemplo:

public static T ToEnum<T>(this string enumValue) : where T : struct, IConvertible
{
    return (T)Enum.Parse(typeof(T), enumValue);
}

entonces puedes hacer

TestEnum reqValue = "Value1".ToEnum<TestEnum>();

Answer 3

Desde la base de datos SQL obtener enumeración como:

SqlDataReader dr = selectCmd.ExecuteReader();
while (dr.Read()) {
   EnumType et = (EnumType)Enum.Parse(typeof(EnumType), dr.GetString(0));
   ....         
}

Answer 4

Hay muchas maneras de hacer esto, pero si quieres un ejemplo simple, esto funcionará. Solo necesita ser mejorado con la codificación defensiva necesaria para verificar la seguridad del tipo y el análisis no válido, etc.

    /// <summary>
    /// Extension method to return an enum value of type T for the given string.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this string value)
    {
        return (T) Enum.Parse(typeof(T), value, true);
    }

    /// <summary>
    /// Extension method to return an enum value of type T for the given int.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this int value)
    {
        var name = Enum.GetName(typeof(T), value);
        return name.ToEnum<T>();
    }

Answer 5

No, no quieres un método genérico. Esto es mucho más fácil:

MyEnum enum = (MyEnum)myInt;

MyEnum enum = (MyEnum)Enum.Parse(typeof(TestEnum), myString);

Creo que también será más rápido.

Answer 6

Podría ser mucho más sencillo si usa los TryParse o Parse y ToObject .

public static class EnumHelper
{
    public static  T GetEnumValue<T>(string str) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }
        T val;
        return Enum.TryParse<T>(str, true, out val) ? val : default(T);
    }

    public static T GetEnumValue<T>(int intValue) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }

        return (T)Enum.ToObject(enumType, intValue);
    }
}

Como lo señaló @chrfin en los comentarios, puede convertirlo en un método de extensión muy fácilmente simplemente agregando this antes del tipo de parámetro que puede ser útil.

Answer 7

Prueba algo como esto

  public static TestEnum GetMyEnum(this string title)
        {    
            EnumBookType st;
            Enum.TryParse(title, out st);
            return st;          
         }

Para que puedas hacer

TestEnum en = "Value1".GetMyEnum();

Answer 8

Simplemente prueba esto

Es otra manera

public enum CaseOriginCode
    {
        Web = 0,
        Email = 1,
        Telefoon = 2
    }

public void setCaseOriginCode(string CaseOriginCode)
{
    int caseOriginCode = (int)(CaseOriginCode)Enum.Parse(typeof(CaseOriginCode), CaseOriginCode);
}

Es un comentario para tu artículo.