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.