C’è un modo per scorrere tutti i valori enum?

Possibile duplicato:
C #: come enumerare un enum?

L’argomento dice tutto. Voglio usarlo per aggiungere i valori di un enum in una combobox.

Grazie

vIceBerg

string[] names = Enum.GetNames (typeof(MyEnum)); 

Quindi compila il menu a discesa con l’array

So che altri hanno già risposto con una risposta corretta, tuttavia, se si desidera utilizzare le enumerazioni in una casella combinata, è ansible che si desideri eseguire il comando extra e associare le stringhe all’enumerazione in modo da poter fornire ulteriori dettagli nel stringa visualizzata (come gli spazi tra le parole o le stringhe di visualizzazione che utilizzano l’involucro che non corrisponde agli standard di codifica)

Questo post di blog può essere utile – Associare stringhe con enumerazioni in c #

 public enum States { California, [Description("New Mexico")] NewMexico, [Description("New York")] NewYork, [Description("South Carolina")] SouthCarolina, Tennessee, Washington } 

Come bonus, ha anche fornito un metodo di utilità per enumerare l’enumerazione che ora ho aggiornato con i commenti di Jon Skeet

 public static IEnumerable EnumToList() where T : struct { Type enumType = typeof(T); // Can't use generic type constraints on value types, // so have to do check like this if (enumType.BaseType != typeof(Enum)) throw new ArgumentException("T must be of type System.Enum"); Array enumValArray = Enum.GetValues(enumType); List enumValList = new List(); foreach (T val in enumValArray) { enumValList.Add(val.ToString()); } return enumValList; } 

Jon ha anche sottolineato che in C # 3.0 può essere semplificato per qualcosa di simile a questo (che ora sta diventando così leggero che immagino si possa semplicemente farlo in linea):

 public static IEnumerable EnumToList() where T : struct { return Enum.GetValues(typeof(T)).Cast(); } // Using above method statesComboBox.Items = EnumToList(); // Inline statesComboBox.Items = Enum.GetValues(typeof(States)).Cast(); 

Utilizzare il metodo Enum.GetValues:

 foreach (TestEnum en in Enum.GetValues(typeof(TestEnum))) { ... } 

Non è necessario eseguire il cast in una stringa e in questo modo è ansible recuperarli semplicemente inoltrando la proprietà SelectedItem a un valore TestEnum direttamente.

È ansible eseguire l’iterazione attraverso la matrice restituita dal metodo Enum.GetNames .

 public class GetNamesTest { enum Colors { Red, Green, Blue, Yellow }; enum Styles { Plaid, Striped, Tartan, Corduroy }; public static void Main() { Console.WriteLine("The values of the Colors Enum are:"); foreach(string s in Enum.GetNames(typeof(Colors))) Console.WriteLine(s); Console.WriteLine(); Console.WriteLine("The values of the Styles Enum are:"); foreach(string s in Enum.GetNames(typeof(Styles))) Console.WriteLine(s); } } 

Se hai bisogno che i valori della combo corrispondano ai valori dell’enum puoi usare anche qualcosa del genere:

 foreach (TheEnum value in Enum.GetValues(typeof(TheEnum))) dropDown.Items.Add(new ListItem( value.ToString(), ((int)value).ToString() ); 

In questo modo puoi mostrare i testi nel menu a discesa e ottenere di nuovo il valore (nella proprietà SelectedValue)

.NET 3.5 semplifica l’utilizzo dei metodi di estensione:

 enum Color {Red, Green, Blue} 

Può essere iterato con

 Enum.GetValues(typeof(Color)).Cast() 

o definire un nuovo metodo generico statico:

 static IEnumerable GetValues() { return Enum.GetValues(typeof(T)).Cast(); } 

Tieni presente che l’iterazione con il metodo Enum.GetValues ​​() utilizza la riflessione e pertanto presenta penalizzazioni prestazionali.

Il problema con l’utilizzo delle enumerazioni per popolare i pull down è che non si hanno strani personaggi o spazi nelle enumerazioni. Ho del codice che estende le enumerazioni in modo da poter aggiungere qualsiasi carattere tu voglia.

Usalo in questo modo ..

 public enum eCarType { [StringValue("Saloon / Sedan")] Saloon = 5, [StringValue("Coupe")] Coupe = 4, [StringValue("Estate / Wagon")] Estate = 6, [StringValue("Hatchback")] Hatchback = 8, [StringValue("Utility")] Ute = 1, } 

Collega i dati in questo modo ..

 StringEnum CarTypes = new StringEnum(typeof(eCarTypes)); cmbCarTypes.DataSource = CarTypes.GetGenericListValues(); 

Ecco la class che estende l’enum.

 // Author: Donny V. // blog: http://donnyvblog.blogspot.com using System; using System.Collections; using System.Collections.Generic; using System.Reflection; namespace xEnums { #region Class StringEnum ///  /// Helper class for working with 'extended' enums using  attributes. ///  public class StringEnum { #region Instance implementation private Type _enumType; private static Hashtable _stringValues = new Hashtable(); ///  /// Creates a new  instance. ///  /// Enum type. public StringEnum(Type enumType) { if (!enumType.IsEnum) throw new ArgumentException(String.Format("Supplied type must be an Enum. Type was {0}", enumType.ToString())); _enumType = enumType; } ///  /// Gets the string value associated with the given enum value. ///  /// Name of the enum value. /// String Value public string GetStringValue(string valueName) { Enum enumType; string stringValue = null; try { enumType = (Enum) Enum.Parse(_enumType, valueName); stringValue = GetStringValue(enumType); } catch (Exception) { }//Swallow! return stringValue; } ///  /// Gets the string values associated with the enum. ///  /// String value array public Array GetStringValues() { ArrayList values = new ArrayList(); //Look for our string value associated with fields in this enum foreach (FieldInfo fi in _enumType.GetFields()) { //Check for our custom attribute StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) values.Add(attrs[0].Value); } return values.ToArray(); } ///  /// Gets the values as a 'bindable' list datasource. ///  /// IList for data binding public IList GetListValues() { Type underlyingType = Enum.GetUnderlyingType(_enumType); ArrayList values = new ArrayList(); //List values = new List(); //Look for our string value associated with fields in this enum foreach (FieldInfo fi in _enumType.GetFields()) { //Check for our custom attribute StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) values.Add(new DictionaryEntry(Convert.ChangeType(Enum.Parse(_enumType, fi.Name), underlyingType), attrs[0].Value)); } return values; } ///  /// Gets the values as a 'bindable' list datasource. ///This is a newer version of 'GetListValues()' ///  /// IList for data binding public IList GetGenericListValues() { Type underlyingType = Enum.GetUnderlyingType(_enumType); List values = new List(); //Look for our string value associated with fields in this enum foreach (FieldInfo fi in _enumType.GetFields()) { //Check for our custom attribute StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof(StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) values.Add(attrs[0].Value); } return values; } ///  /// Return the existence of the given string value within the enum. ///  /// String value. /// Existence of the string value public bool IsStringDefined(string stringValue) { return Parse(_enumType, stringValue) != null; } ///  /// Return the existence of the given string value within the enum. ///  /// String value. /// Denotes whether to conduct a case-insensitive match on the supplied string value /// Existence of the string value public bool IsStringDefined(string stringValue, bool ignoreCase) { return Parse(_enumType, stringValue, ignoreCase) != null; } ///  /// Gets the underlying enum type for this instance. ///  ///  public Type EnumType { get { return _enumType; } } #endregion #region Static implementation ///  /// Gets a string value for a particular enum value. ///  /// Value. /// String Value associated via a  attribute, or null if not found. public static string GetStringValue(Enum value) { string output = null; Type type = value.GetType(); if (_stringValues.ContainsKey(value)) output = (_stringValues[value] as StringValueAttribute).Value; else { //Look for our 'StringValueAttribute' in the field's custom attributes FieldInfo fi = type.GetField(value.ToString()); StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) { _stringValues.Add(value, attrs[0]); output = attrs[0].Value; } } return output; } ///  /// Parses the supplied enum and string value to find an associated enum value (case sensitive). ///  /// Type. /// String value. /// Enum value associated with the string value, or null if not found. public static object Parse(Type type, string stringValue) { return Parse(type, stringValue, false); } ///  /// Parses the supplied enum and string value to find an associated enum value. ///  /// Type. /// String value. /// Denotes whether to conduct a case-insensitive match on the supplied string value /// Enum value associated with the string value, or null if not found. public static object Parse(Type type, string stringValue, bool ignoreCase) { object output = null; string enumStringValue = null; if (!type.IsEnum) throw new ArgumentException(String.Format("Supplied type must be an Enum. Type was {0}", type.ToString())); //Look for our string value associated with fields in this enum foreach (FieldInfo fi in type.GetFields()) { //Check for our custom attribute StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) enumStringValue = attrs[0].Value; //Check for equality then select actual enum value. if (string.Compare(enumStringValue, stringValue, ignoreCase) == 0) { output = Enum.Parse(type, fi.Name); break; } } return output; } ///  /// Return the existence of the given string value within the enum. ///  /// String value. /// Type of enum /// Existence of the string value public static bool IsStringDefined(Type enumType, string stringValue) { return Parse(enumType, stringValue) != null; } ///  /// Return the existence of the given string value within the enum. ///  /// String value. /// Type of enum /// Denotes whether to conduct a case-insensitive match on the supplied string value /// Existence of the string value public static bool IsStringDefined(Type enumType, string stringValue, bool ignoreCase) { return Parse(enumType, stringValue, ignoreCase) != null; } #endregion } #endregion #region Class StringValueAttribute ///  /// Simple attribute class for storing String Values ///  public class StringValueAttribute : Attribute { private string _value; ///  /// Creates a new  instance. ///  /// Value. public StringValueAttribute(string value) { _value = value; } ///  /// Gets the value. ///  ///  public string Value { get { return _value; } } } #endregion } 

È spesso utile definire un minimo e un massimo all’interno dell’enumerazione, che sarà sempre il primo e l’ultimo elemento. Ecco un esempio molto semplice usando la syntax di Delphi:

 procedure TForm1.Button1Click(Sender: TObject); type TEmployeeTypes = (etMin, etHourly, etSalary, etContractor, etMax); var i : TEmployeeTypes; begin for i := etMin to etMax do begin //do something end; end; 

Poco più “complicato” (forse eccessivo) ma utilizzo questi due metodi per restituire i dizionari da utilizzare come origini dati. Il primo restituisce il nome come chiave e il secondo valore come chiave.

 public static IDictionary  ConvertEnumToDictionaryNameFirst  ()
 {
   if (typeof (K) .BaseType! = typeof (Enum))
   {
     lanciare una nuova InvalidCastException ();
   }

   restituire Enum.GetValues ​​(typeof (K)). Cast  (). ToDictionary (currentItem 
     => Enum.GetName (typeof (K), currentItem));
 }

O potresti farlo


 public static IDictionary  ConvertEnumToDictionaryValueFirst  ()
 {
   if (typeof (K) .BaseType! = typeof (Enum))
   {
     lanciare una nuova InvalidCastException ();
   }

   return Enum.GetNames (typeof (K)). Cast  (). ToDictionary (currentItem 
     => (int) Enum.Parse (typeof (K), currentItem));
 }

Questo presuppone che si stia utilizzando 3.5. Dovresti sostituire le espressioni lambda se no.

Uso:


   Elenco di dizionari = ConvertEnumToDictionaryValueFirst  ();

   usando il sistema;
   using System.Collections.Generic;
   using System.Linq;