C # Iterazione attraverso un'enumerazione? (Indicizzazione di un System.Array)

Ho il codice seguente:

// 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] ); 
}

Tuttavia, non posso indicizzare i valori. C'è un modo più semplice per farlo?

O mi sono perso completamente qualcosa!

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

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

Oppure puoi eseguire il cast del System.Array che viene restituito:

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]);
}

Ma puoi essere sicuro che GetValues ​​restituisca i valori nello stesso ordine in cui GetNames restituisce i nomi?

Devi eseguire il cast dell'array: l'array restituito è in realtà del tipo richiesto, cioè myEnum[]se chiedi typeof(myEnum):

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

Quindi values[0]ecc

Puoi eseguire il cast di tale array su diversi tipi di array:

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

o se vuoi i valori interi:

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

Ovviamente puoi iterare quegli array trasmessi :)

Che ne dici di un elenco di dizionari?

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));
}

e ovviamente puoi cambiare il tipo di valore del dizionario in qualunque siano i tuoi valori enum.

Un'altra soluzione, con interessanti possibilità:

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;
  } 
}

Eccone un altro. Avevamo bisogno di fornire nomi descrittivi per i nostri EnumValues. Abbiamo usato System.ComponentModel.DescriptionAttribute per mostrare un valore stringa personalizzato per ogni valore 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;
    }
}

In uso

 public enum TestEnum
 { 
        [Description("Something 1")]
        Dr = 0,
        [Description("Something 2")]
        Mr = 1
 }



    static void Main(string[] args)
    {

        var vals = StaticClass.GetEnumFormattedNames<TestEnum>();
    }

Questo finirà per restituire "Something 1", "Something 2"

Che ne dici di usare un ciclo foreach, forse potresti lavorarci?

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

qualcosa del genere forse?

Vecchia domanda, ma un approccio leggermente più pulito usando LINQ .Cast<>()

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

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

Array ha un metodo GetValue (Int32) che puoi usare per recuperare il valore in corrispondenza di un indice specificato.

Array.GetValue

Puoi semplificarlo usando le stringhe di formato. Uso il seguente frammento nei messaggi di utilizzo:

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);
}

L'identificatore di formato D formatta il valore enum come decimale. C'è anche un identificatore X che fornisce un output esadecimale.

L'identificatore G formatta un'enumerazione come stringa. Se l'attributo Flags viene applicato all'enumerazione, vengono supportati anche i valori combinati. C'è uno specificatore F che agisce come se Flags fosse sempre presente.

Vedere Enum.Format ().

Nei risultati Enum.GetValues, il cast a int produce il valore numerico. L'utilizzo di ToString () produce il nome descrittivo. Non sono necessarie altre chiamate 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
 */

Ecco un modo semplice per scorrere il tuo oggetto Enum personalizzato

For Each enumValue As Integer In [Enum].GetValues(GetType(MyEnum))

     Print([Enum].GetName(GetType(MyEnum), enumValue).ToString)

Next

Domanda antica, ma la risposta di 3Dave ha fornito l'approccio più semplice. Avevo bisogno di un piccolo metodo di supporto per generare uno script Sql per decodificare un valore enum nel database per il debug. Ha funzionato alla grande:

    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,";
    }

Ce l'ho in un metodo statico, quindi l'utilizzo è:

var cheater = MyStaticClass.EnumToCheater<MyEnum>()