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

Question

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?

Oppure mi sono perso qualcosa del tutto!

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

In alternativa, puoi eseguire il cast del System.Array 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?

Answer 2

È necessario eseguire il cast dell'array: l'array restituito è in realtà del tipo richiesto, ovvero myEnum[] se si richiede typeof(myEnum):

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

Quindi values[0] ecc

Answer 3

Puoi trasmettere quell'array a diversi tipi di array:

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

o se vuoi i valori interi:

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

Puoi ovviamente iterare quegli array espressi :)

Answer 4

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 sia il tuo valore enum.

Answer 5

Un'altra soluzione, con possibilità interessanti:

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

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

Answer 7

Che ne dici di usare un ciclo foreach, forse potresti lavorare con quello?

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

qualcosa del genere forse?

Answer 8

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

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

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

Answer 9

L'array ha un metodo GetValue (Int32) che è possibile utilizzare per recuperare il valore in un indice specificato.

Array.GetValue

Answer 10

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.

Lo specificatore G formatta un'enum come stringa. Se l'attributo Flags viene applicato all'enum, vengono supportati anche i valori combinati. C'è un identificatore F che si comporta come se le bandiere siano sempre presenti.

Vedi Enum.Format ().

Answer 11

Nei risultati di Enum.GetValues, il casting su int produce il valore numerico. L'uso 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
 */

Answer 12

Ecco un modo semplice per iterare l'oggetto Enum personalizzato

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

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

Next

Answer 13

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

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

var cheater = MyStaticClass.EnumToCheater<MyEnum>()