C# Iterar a través de una enumeración?(La indización de un Sistema.De la matriz)

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 valores de índice.Hay una manera más fácil de hacer esto?

O he perdido algo totalmente!

Answer 1

Array values = Enum.GetValues(typeof(myEnum));

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

O, usted puede convertir el Sistema.La matriz 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 como GetNames devuelve los nombres ?

Answer 2

Debe convertir 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));

Entonces values[0] etc.

Answer 3

Puede lanzar esa matriz a diferentes tipos de matrices:

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

o si desea los valores enteros:

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

Puede iterar esas matrices fundidas, por supuesto :)

Answer 4

¿Qué tal una lista de diccionario?

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 cualesquiera que sean sus valores de enumeración.

Answer 5

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 6

Aquí hay otro. Necesitábamos proporcionar nombres descriptivos para nuestros EnumValues. Utilizamos el System.ComponentModel.DescriptionAttribute para mostrar un valor de cadena personalizado para cada valor de enumeración.

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 " Algo 1 " ;, " Algo 2 "

Answer 7

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

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

¿

algo así quizás?

Answer 8

Pregunta anterior, pero un enfoque un poco más limpio utilizando .Cast<>()

de LINQ

var values = Enum.GetValues(typeof(MyEnum)).Cast<MyEnum>();

foreach(var val in values)
{
    Console.WriteLine("Member: {0}",val.ToString());     
}

Answer 9

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

Array.GetValue

Answer 10

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 de enumeración 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 valores combinados. Hay un especificador F que actúa como si Flags estuviera siempre presente.

Ver Enum.Format ().

Answer 11

En los resultados de Enum.GetValues, la conversión a int produce el valor numérico. Usar 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 12

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 13

Pregunta antigua, pero la respuesta de 3Dave proporcionó el enfoque más fácil. Necesitaba un pequeño método auxiliar para generar un script SQL para decodificar un valor de enumeración en la base de datos para la depuración. Funcionó muy bien:

    public static string EnumToCheater<T>() {
        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, por lo que el uso es:

var cheater = MyStaticClass.EnumToCheater<MyEnum>()