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

enums iteration

Question

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?

Answer 1

¿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?

Answer 2

¿Qué tal una lista de diccionarios?

Dictionary<string, int> list = new Dictionary<string, int>();
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.

Answer 3

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<string> GetEnumFormattedNames<TEnum>()
{
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<string> formattedNames = new List<string>();
var list = Enum.GetValues(enumType).OfType<TEnum>().ToList<TEnum>();
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<TestEnum>();
}

Esto terminará devolviendo "Something 1", "Something 2"

Answer 4

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

Answer 5

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

Array.GetValue

Answer 6

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
*/

Answer 7

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.

Answer 8

Otra solución, con posibilidades interesantes:

enum Days { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }
static class Helpers
{
public static IEnumerable<Days> 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;
}
}

Answer 9

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

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

Answer 10

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 :)

Answer 11

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 ().

Answer 12

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?