Obtener valor de enumeración a través de la reflexión

Question

Tengo una enumeración sencilla

public enum TestEnum 
{ 
    TestOne = 3, 
    TestTwo = 4 
} 

var testing = TestEnum.TestOne; 

Y Quiero recuperar su valor (3) a través de la reflexión. ¿Alguna idea sobre cómo hacer esto?

Answer 1

Gran pregunta Mat.

El escenario de la cuestión es la siguiente:

Tiene alguna desconocida tipo de enumeración y algunos valor desconocido de ese tipo y que desea obtener el valor numérico subyacente de ese valor desconocido .

Esta es la forma de una línea de hacer esto utilizando la reflexión:

object underlyingValue = Convert.ChangeType(value, Enum.GetUnderlyingType(value.GetType())); 

Si el valor pasa a ser TestEnum.TestTwo, a continuación, value.GetType() sería igual a typeof(TestEnum), Enum.GetUnderlyingType(value.GetType()) sería igual a typeof(int) y el valor sería ser 3 (en caja, ver http://msdn.microsoft.com/en-us/library/yz2be5wk.aspx para más detalles sobre boxeo y valores de unboxing).

¿Por qué alguna vez necesitaría escribir tal código? En mi caso, tengo una rutina que copia valores de un modelo de vista a un modelo. Utilizo esto en todos mis manejadores en un proyecto ASP.NET MVC como parte de una arquitectura muy limpia y elegante para escribir manejadores que no tienen los problemas de seguridad que los controladores generados por las plantillas de Microsoft.

El modelo es generado por Entity Framework desde la base de datos y contiene un campo de tipo int. El modelo de vista tiene un campo de tipo enum, vamos a llamarlo RecordStatus, que he definido en otro lugar de mi proyecto. Decidí apoyar las enumeraciones completamente en mi marco. Pero ahora hay una falta de coincidencia entre el tipo de campo en el modelo y el tipo del campo correspondiente en el modelo de vista. Mi código detecta esto y convierte la enumeración en un int usando el código similar al delineador dado arriba.

Answer 2

No hay necesidad de reflexión:

int value = (int)TestEnum.TestOne; 

Answer 3

¿Por qué necesita la reflexión?

int value = (int)TestEnum.TestOne; 

Answer 4

código completo: How to Get Enum Values with Reflection in C#

MemberInfo[] memberInfos = typeof(MyEnum).GetMembers(BindingFlags.Public | BindingFlags.Static); 
string alerta = ""; 
for (int i = 0; i < memberInfos.Length; i++) { 
alerta += memberInfos[i].Name + " - "; 
alerta += memberInfos[i].GetType().Name + "\n"; 
} 

Answer 5

este artículo es el mejor para usted a través de la reflexión con enumeraciones: Enum Reflection

Answer 6

O bien, si necesitaba el objeto de enumeración real (de tipo TestEnum):

MemberInfo[] memberInfos = typeof(MyEnum).GetMembers(BindingFlags.Public | BindingFlags.Static); 
string alerta = ""; 
for (int i = 0; i < memberInfos.Length; i++) { 

alerta += memberInfos[i].Name + " - "; 


/* alerta += memberInfos[i].GetType().Name + "\n"; */ 

// the actual enum object (of type MyEnum, above code is of type System.Reflection.RuntimeFieldInfo) 
object enumValue = memberInfos[i].GetValue(0); 
alerta += enumValue.ToString() + "\n"; 
} 

Answer 7

Puede usar el sistema.ayudantes de enumeración:

System.Type enumType = typeof(TestEnum); 
System.Type enumUnderlyingType = System.Enum.GetUnderlyingType(enumType); 
System.Array enumValues = System.Enum.GetValues(enumType); 

for (int i=0; i < enumValues.Length; i++) 
{ 
    // Retrieve the value of the ith enum item. 
    object value = enumValues.GetValue(i); 

    // Convert the value to its underlying type (int, byte, long, ...) 
    object underlyingValue = System.Convert.ChangeType(value, enumUnderlyingType); 

    System.Console.WriteLine(underlyingValue); 
} 

salidas

Answer 8

intente lo siguiente:

System.Array enumValues = System.Enum.GetValues(typeof(MyEnum)); 
Type underlyingType = System.Enum.GetUnderlyingType(MyEnum); 

foreach (object enumValue in enumValues) 
    System.Console.WriteLine(String.Format("{0}",Convert.ChangeType(enumValue ,underlyingType))); 

Answer 9

simples.

var value = propertyInfo.GetValue(obj); // this return TestOne or TestTwo 

var enumValue = Convert.ChangeType(value, typeof(int)); // this return 3 or 4 

Answer 10

Hola que tienen esta alternativa:

Type typevar = GetType([YourEnum])

Y luego ... ... Puede obtener nombres usando typevar.GetEnumNames devolver una matriz con los nombres y para obtener valores utilizando type.GetEnumValues, devolviendo una matriz con valores.

Answer 11

System.Type.GetType("Namespace Name" + "." + "Class Name" + "+" + "Enum Name") 

Dim fieldInfos() As System.Reflection.FieldInfo = System.Type.GetType("YourNameSpaceName.TestClass+TestEnum").GetFields 

For Each f As System.Reflection.FieldInfo In fieldInfos 
    If f.IsLiteral Then 
     MsgBox(f.Name & " : " & CType(f.GetValue(Nothing), Integer) & vbCrLf) 
    End If 
Next 

Public Class TestClass 
    Public Enum TestEnum 
     val1 = 20 
     val2 = 30 
    End Enum 
End Class 

que funciona

Answer 12

En mi caso, el problema se MyEnum no se ha encontrado debido a un signo + conseguir el tipo de montaje (línea 2):

var dll = System.Reflection.Assembly.LoadFile("pathToDll"); 
Type myEnum = dll.GetType("namespace+MyEnum"); 
System.Array myEnumValues = System.Enum.GetValues(myEnum); 

Answer 13

Para su requisito es tan simple como la gente ya lo señaló. Simplemente envía el objeto enum a int y obtendrías el valor numérico de la enumeración.

int value = (int) TestEnum.TestOne; 

Sin embargo, si es necesario mezclar los valores de enum con | (OR bit a bit) p.

var value = TestEnum.TestOne | TestEnum.TestTwo; 

y desea obtener lo que las opciones que mezclaba abajo valor representa, aquí es cómo usted podría hacerlo (nota: esto es para las enumeraciones que representados por valores int destinados para aprovechar operatations bit a bit):

primero, obtenga las opciones de enumeración junto con sus valores en un diccionario.

var all_options_dic = typeof(TestEnum).GetEnumValues().Cast<object>().ToDictionary(k=>k.ToString(), v=>(int) v); 

Filtra el diccionario para devolver solo las opciones mixtas.

var filtered = all_options_dic.Where(x => (x.Value & (int) options) != 0).ToDictionary(k=>k.Key, v=>v.Value); 

hagan cualquier lógica con sus opciones. p.ej. imprimiéndolos, convirtiéndolos en List, etc.:

foreach (var key in filtered.Keys) 
     { 
      Console.WriteLine(key + " = " + filtered[key]); 
     } 

Espero que esto ayude.