Есть ли способ перебора всех значений enum?

Question

Можно создать дубликат:
C#: How to enumerate an enum?

Субъект говорит, что все. Я хочу использовать это, чтобы добавить значения перечисления в combobox.

Благодаря

vIceBerg

Answer 1

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

Тогда просто заполнить раскрывающийся лозы массив

Answer 2

Часто бывает полезно определить Min и Max внутри вашего перечисления, который всегда будет первым и последние элементы. Вот очень простой пример с использованием синтаксиса 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; 

Answer 3

Вы можете перебирать массив, возвращаемый Enum.GetNames method вместо этого.

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

Answer 4

Используйте метод Enum.GetValues:

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

Вам не нужно, чтобы бросить их в строку, и таким образом, вы можете просто получить их обратно, бросая имущество SelectedItem в TestEnum значение напрямую.

Answer 5

Если вам нужны значения комбо, чтобы соответствовать значениям перечисления можно использовать что-то вроде этого:

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

Таким образом, вы можете показать тексты в выпадающем списке и получить обратно value (в свойстве SelectedValue)

Answer 6

Я знаю, что другие уже ответили правильным ответом, однако, если вы хотите использовать перечисления в поле со списком, вы можете захотеть добавить дополнительный ярд и связать строки с enum, чтобы вы могли предоставить более подробную информацию в отображаемой строке (например, пробелы между словами или отображаемыми строками, используя корпус, который делает esn't соответствовать вашим стандартам кодирования)

Эта запись блога может быть полезным - Associating Strings with enums in c#

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

В качестве бонуса, он также поставляется служебный метод для перечисления перечисление, которое я в настоящее время обновляется с Jon Скита комментарии

public static IEnumerable<T> EnumToList<T>() 
    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<T> enumValList = new List<T>(); 

    foreach (T val in enumValArray) 
    { 
     enumValList.Add(val.ToString()); 
    } 

    return enumValList; 
} 

Джон также отметил, что в C# 3.0 это может быть упрощено к чему-то вроде этого (который теперь становится настолько легким, что я предположил бы, что вы могли бы просто сделать это в линии):

public static IEnumerable<T> EnumToList<T>() 
    where T : struct 
{ 
    return Enum.GetValues(typeof(T)).Cast<T>(); 
} 

// Using above method 
statesComboBox.Items = EnumToList<States>(); 

// Inline 
statesComboBox.Items = Enum.GetValues(typeof(States)).Cast<States>(); 

Answer 7

Немного более «сложный» (может быть, излишний), но я использую эти два метода, чтобы использовать словари для использования в качестве источников данных. Первый возвращает имя как ключ, а второе значение - как ключ.

 
public static IDictionary<string, int> ConvertEnumToDictionaryNameFirst<K>() 
{ 
    if (typeof(K).BaseType != typeof(Enum)) 
    { 
    throw new InvalidCastException(); 
    } 

    return Enum.GetValues(typeof(K)).Cast<int>().ToDictionary(currentItem 
    => Enum.GetName(typeof(K), currentItem)); 
} 

Или вы могли бы сделать

 

public static IDictionary<int, string> ConvertEnumToDictionaryValueFirst<K>() 
{ 
    if (typeof(K).BaseType != typeof(Enum)) 
    { 
    throw new InvalidCastException(); 
    } 

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

Это предполагает, что вы используете 3.5, хотя. Вы должны заменить лямбда-выражения, если нет.

Использование:

 

    Dictionary list = ConvertEnumToDictionaryValueFirst<SomeEnum>(); 

 
    using System; 
    using System.Collections.Generic; 
    using System.Linq; 

Answer 8

Проблема с использованием перечислений для заполнения тянуть падения является то, что вы можите имеют странные символы или пробелы в перечислений. У меня есть код, который расширяет перечисления, чтобы вы могли добавить любого персонажа, которого хотите.

Используйте это так .. данные

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

Bind как так ..

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

Вот класс, который расширяет 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 

    /// <summary> 
    /// Helper class for working with 'extended' enums using <see cref="StringValueAttribute"/> attributes. 
    /// </summary> 
    public class StringEnum 
    { 
     #region Instance implementation 

     private Type _enumType; 
     private static Hashtable _stringValues = new Hashtable(); 

     /// <summary> 
     /// Creates a new <see cref="StringEnum"/> instance. 
     /// </summary> 
     /// <param name="enumType">Enum type.</param> 
     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; 
     } 

     /// <summary> 
     /// Gets the string value associated with the given enum value. 
     /// </summary> 
     /// <param name="valueName">Name of the enum value.</param> 
     /// <returns>String Value</returns> 
     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; 
     } 

     /// <summary> 
     /// Gets the string values associated with the enum. 
     /// </summary> 
     /// <returns>String value array</returns> 
     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(); 
     } 

     /// <summary> 
     /// Gets the values as a 'bindable' list datasource. 
     /// </summary> 
     /// <returns>IList for data binding</returns> 
     public IList GetListValues() 
     { 
      Type underlyingType = Enum.GetUnderlyingType(_enumType); 
      ArrayList values = new ArrayList(); 
      //List<string> values = new List<string>(); 

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

     } 

     /// <summary> 
     /// Gets the values as a 'bindable' list<string> datasource. 
     ///This is a newer version of 'GetListValues()' 
     /// </summary> 
     /// <returns>IList<string> for data binding</returns> 
     public IList<string> GetGenericListValues() 
     { 
      Type underlyingType = Enum.GetUnderlyingType(_enumType); 
      List<string> values = new List<string>(); 

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

     } 

     /// <summary> 
     /// Return the existence of the given string value within the enum. 
     /// </summary> 
     /// <param name="stringValue">String value.</param> 
     /// <returns>Existence of the string value</returns> 
     public bool IsStringDefined(string stringValue) 
     { 
      return Parse(_enumType, stringValue) != null; 
     } 

     /// <summary> 
     /// Return the existence of the given string value within the enum. 
     /// </summary> 
     /// <param name="stringValue">String value.</param> 
     /// <param name="ignoreCase">Denotes whether to conduct a case-insensitive match on the supplied string value</param> 
     /// <returns>Existence of the string value</returns> 
     public bool IsStringDefined(string stringValue, bool ignoreCase) 
     { 
      return Parse(_enumType, stringValue, ignoreCase) != null; 
     } 

     /// <summary> 
     /// Gets the underlying enum type for this instance. 
     /// </summary> 
     /// <value></value> 
     public Type EnumType 
     { 
      get { return _enumType; } 
     } 

     #endregion 

     #region Static implementation 

     /// <summary> 
     /// Gets a string value for a particular enum value. 
     /// </summary> 
     /// <param name="value">Value.</param> 
     /// <returns>String Value associated via a <see cref="StringValueAttribute"/> attribute, or null if not found.</returns> 
     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; 

     } 

     /// <summary> 
     /// Parses the supplied enum and string value to find an associated enum value (case sensitive). 
     /// </summary> 
     /// <param name="type">Type.</param> 
     /// <param name="stringValue">String value.</param> 
     /// <returns>Enum value associated with the string value, or null if not found.</returns> 
     public static object Parse(Type type, string stringValue) 
     { 
      return Parse(type, stringValue, false); 
     } 

     /// <summary> 
     /// Parses the supplied enum and string value to find an associated enum value. 
     /// </summary> 
     /// <param name="type">Type.</param> 
     /// <param name="stringValue">String value.</param> 
     /// <param name="ignoreCase">Denotes whether to conduct a case-insensitive match on the supplied string value</param> 
     /// <returns>Enum value associated with the string value, or null if not found.</returns> 
     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; 
     } 

     /// <summary> 
     /// Return the existence of the given string value within the enum. 
     /// </summary> 
     /// <param name="stringValue">String value.</param> 
     /// <param name="enumType">Type of enum</param> 
     /// <returns>Existence of the string value</returns> 
     public static bool IsStringDefined(Type enumType, string stringValue) 
     { 
      return Parse(enumType, stringValue) != null; 
     } 

     /// <summary> 
     /// Return the existence of the given string value within the enum. 
     /// </summary> 
     /// <param name="stringValue">String value.</param> 
     /// <param name="enumType">Type of enum</param> 
     /// <param name="ignoreCase">Denotes whether to conduct a case-insensitive match on the supplied string value</param> 
     /// <returns>Existence of the string value</returns> 
     public static bool IsStringDefined(Type enumType, string stringValue, bool ignoreCase) 
     { 
      return Parse(enumType, stringValue, ignoreCase) != null; 
     } 

     #endregion 
    } 

    #endregion 

    #region Class StringValueAttribute 

    /// <summary> 
    /// Simple attribute class for storing String Values 
    /// </summary> 
    public class StringValueAttribute : Attribute 
    { 
     private string _value; 

     /// <summary> 
     /// Creates a new <see cref="StringValueAttribute"/> instance. 
     /// </summary> 
     /// <param name="value">Value.</param> 
     public StringValueAttribute(string value) 
     { 
      _value = value; 
     } 

     /// <summary> 
     /// Gets the value. 
     /// </summary> 
     /// <value></value> 
     public string Value 
     { 
      get { return _value; } 
     } 
    } 

    #endregion 
} 

Answer 9

.NET 3.5 делает его простым с помощью методов расширения:

enum Color {Red, Green, Blue} 

Может быть итерация с

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

или определить новый статический универсальный метод:

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

Имейте в виду, что итерация с помощью метода Enum.GetValues ​​() использует отражение и, следовательно, имеет штрафы за производительность.