C # Iterar a través de una enumeración? (Indexando un Sistema.Array)

Tengo el siguiente código:

// Obtain the string names of all the elements within myEnum String[] names = Enum.GetNames( typeof( myEnum ) ); // Obtain the values of all the elements within myEnum Array values = Enum.GetValues( typeof( myEnum ) ); // Print the names and values to file for ( int i = 0; i < names.Length; i++ ) { print( names[i], values[i] ); } 

Sin embargo, no puedo indexar valores. ¿Hay alguna forma más fácil de hacer esto?

¿O me he perdido algo completamente?

 Array values = Enum.GetValues(typeof(myEnum)); foreach( MyEnum val in values ) { Console.WriteLine (String.Format("{0}: {1}", Enum.GetName(typeof(MyEnum), val), val)); } 

O bien, puede transmitir el System.Array que se devuelve:

 string[] names = Enum.GetNames(typeof(MyEnum)); MyEnum[] values = (MyEnum[])Enum.GetValues(typeof(MyEnum)); for( int i = 0; i < names.Length; i++ ) { print(names[i], values[i]); } 

Pero, ¿puede estar seguro de que GetValues ​​devuelve los valores en el mismo orden en que GetNames devuelve los nombres?

Necesita lanzar la matriz: la matriz devuelta es en realidad del tipo solicitado, es decir, myEnum[] si solicita typeof(myEnum) :

 myEnum[] values = (myEnum[]) Enum.GetValues(typeof(myEnum)); 

Luego values[0] etc.

Puede lanzar esa matriz a diferentes tipos de matrices:

 myEnum[] values = (myEnum[])Enum.GetValues(typeof(myEnum)); 

o si quieres los valores enteros:

 int[] values = (int[])Enum.GetValues(typeof(myEnum)); 

Puedes iterar esas matrices encastadas por supuesto 🙂

¿Qué tal una lista de diccionarios?

 Dictionary list = new Dictionary(); foreach( var item in Enum.GetNames(typeof(MyEnum)) ) { list.Add(item, (int)Enum.Parse(typeof(MyEnum), item)); } 

y, por supuesto, puede cambiar el tipo de valor del diccionario a cualquiera que sean sus valores enum.

Otra solución, con posibilidades interesantes:

 enum Days { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday } static class Helpers { public static IEnumerable AllDays(Days First) { if (First == Days.Monday) { yield return Days.Monday; yield return Days.Tuesday; yield return Days.Wednesday; yield return Days.Thursday; yield return Days.Friday; yield return Days.Saturday; yield return Days.Sunday; } if (First == Days.Saturday) { yield return Days.Saturday; yield return Days.Sunday; yield return Days.Monday; yield return Days.Tuesday; yield return Days.Wednesday; yield return Days.Thursday; yield return Days.Friday; } } 

Aquí está otro. Tuvimos la necesidad de proporcionar nombres amigables para nuestros EnumValues. Usamos System.ComponentModel.DescriptionAttribute para mostrar un valor de cadena personalizado para cada valor enum.

 public static class StaticClass { public static string GetEnumDescription(Enum currentEnum) { string description = String.Empty; DescriptionAttribute da; FieldInfo fi = currentEnum.GetType(). GetField(currentEnum.ToString()); da = (DescriptionAttribute)Attribute.GetCustomAttribute(fi, typeof(DescriptionAttribute)); if (da != null) description = da.Description; else description = currentEnum.ToString(); return description; } public static List GetEnumFormattedNames() { var enumType = typeof(TEnum); if (enumType == typeof(Enum)) throw new ArgumentException("typeof(TEnum) == System.Enum", "TEnum"); if (!(enumType.IsEnum)) throw new ArgumentException(String.Format("typeof({0}).IsEnum == false", enumType), "TEnum"); List formattedNames = new List(); var list = Enum.GetValues(enumType).OfType().ToList(); foreach (TEnum item in list) { formattedNames.Add(GetEnumDescription(item as Enum)); } return formattedNames; } } 

En uso

  public enum TestEnum { [Description("Something 1")] Dr = 0, [Description("Something 2")] Mr = 1 } static void Main(string[] args) { var vals = StaticClass.GetEnumFormattedNames(); } 

Esto terminará devolviendo “Something 1”, “Something 2”

¿Qué pasa con el uso de un bucle Foreach, tal vez podría trabajar con eso?

  int i = 0; foreach (var o in values) { print(names[i], o); i++; } 

algo así tal vez?

Pregunta anterior, pero un enfoque ligeramente más limpio usando LINQ’s .Cast<>()

 var values = Enum.GetValues(typeof(MyEnum)).Cast(); foreach(var val in values) { Console.WriteLine("Member: {0}",val.ToString()); } 

Array tiene un método GetValue (Int32) que puede usar para recuperar el valor en un índice especificado.

Array.GetValue

Puede simplificar esto usando cadenas de formato. Uso el siguiente fragmento en los mensajes de uso:

 writer.WriteLine("Exit codes are a combination of the following:"); foreach (ExitCodes value in Enum.GetValues(typeof(ExitCodes))) { writer.WriteLine(" {0,4:D}: {0:G}", value); } 

El especificador de formato D formatea el valor enum como un decimal. También hay un especificador X que da salida hexadecimal.

El especificador G formatea una enumeración como una cadena. Si el atributo Flags se aplica a la enumeración, también se admiten los valores combinados. Hay un especificador F que actúa como si Flags estuviera siempre presente.

Ver Enum.Format ().

En los resultados Enum.GetValues, la conversión a int produce el valor numérico. El uso de ToString () produce el nombre descriptivo. No se necesitan otras llamadas a Enum.GetName.

 public enum MyEnum { FirstWord, SecondWord, Another = 5 }; // later in some method StringBuilder sb = new StringBuilder(); foreach (var val in Enum.GetValues(typeof(MyEnum))) { int numberValue = (int)val; string friendyName = val.ToString(); sb.Append("Enum number " + numberValue + " has the name " + friendyName + "\n"); } File.WriteAllText(@"C:\temp\myfile.txt", sb.ToString()); // Produces the output file contents: /* Enum number 0 has the name FirstWord Enum number 1 has the name SecondWord Enum number 5 has the name Another */ 

Aquí hay una manera simple de iterar a través de su objeto Enum personalizado

 For Each enumValue As Integer In [Enum].GetValues(GetType(MyEnum)) Print([Enum].GetName(GetType(MyEnum), enumValue).ToString) Next 

Antigua pregunta, pero la respuesta de 3Dave proporcionaba el enfoque más fácil. Necesitaba un pequeño método auxiliar para generar un script Sql para decodificar un valor enum en la base de datos para la depuración. Funcionó de maravilla:

  public static string EnumToCheater() { var sql = ""; foreach (var enumValue in Enum.GetValues(typeof(T))) sql += $@"when {(int) enumValue} then '{enumValue}' "; return $@"case ?? {sql}else '??' end,"; } 

Lo tengo en un método estático, así que el uso es:

 var cheater = MyStaticClass.EnumToCheater()