我如何列举一个枚举?

你怎么能enum在C#中的enum

例如下面的代码不能编译:

 public enum Suit { Spades, Hearts, Clubs, Diamonds } public void EnumerateAllSuitsDemoMethod() { foreach (Suit suit in Suit) { DoSomething(suit); } } 

并给出以下编译时错误:

“西装”是一个“types”,但用作“variables”

它在Suit关键字,第二个失败。

 foreach (Suit suit in Enum.GetValues(typeof(Suit))) { // ... } 

它看起来像你真的想打印每个枚举的名称,而不是值。 在这种情况下Enum.GetNames()似乎是正确的方法。

 public enum Suits { Spades, Hearts, Clubs, Diamonds, NumSuits } public void PrintAllSuits() { foreach (string name in Enum.GetNames(typeof(Suits))) { System.Console.WriteLine(name); } } 

顺便说一句,递增值不是枚举枚举值的好方法。 你应该这样做。

我会使用Enum.GetValues(typeof(Suit))来代替。

 public enum Suits { Spades, Hearts, Clubs, Diamonds, NumSuits } public void PrintAllSuits() { foreach (var suit in Enum.GetValues(typeof(Suits))) { System.Console.WriteLine(suit.ToString()); } } 

我做了一些简单的枚举使用扩展,也许有人可以使用它…

 public static class EnumExtensions { /// <summary> /// Gets all items for an enum value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">The value.</param> /// <returns></returns> public static IEnumerable<T> GetAllItems<T>(this Enum value) { foreach (object item in Enum.GetValues(typeof(T))) { yield return (T)item; } } /// <summary> /// Gets all items for an enum type. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">The value.</param> /// <returns></returns> public static IEnumerable<T> GetAllItems<T>() where T : struct { foreach (object item in Enum.GetValues(typeof(T))) { yield return (T)item; } } /// <summary> /// Gets all combined items from an enum value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">The value.</param> /// <returns></returns> /// <example> /// Displays ValueA and ValueB. /// <code> /// EnumExample dummy = EnumExample.Combi; /// foreach (var item in dummy.GetAllSelectedItems<EnumExample>()) /// { /// Console.WriteLine(item); /// } /// </code> /// </example> public static IEnumerable<T> GetAllSelectedItems<T>(this Enum value) { int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture); foreach (object item in Enum.GetValues(typeof(T))) { int itemAsInt = Convert.ToInt32(item, CultureInfo.InvariantCulture); if (itemAsInt == (valueAsInt & itemAsInt)) { yield return (T)item; } } } /// <summary> /// Determines whether the enum value contains a specific value. /// </summary> /// <param name="value">The value.</param> /// <param name="request">The request.</param> /// <returns> /// <c>true</c> if value contains the specified value; otherwise, <c>false</c>. /// </returns> /// <example> /// <code> /// EnumExample dummy = EnumExample.Combi; /// if (dummy.Contains<EnumExample>(EnumExample.ValueA)) /// { /// Console.WriteLine("dummy contains EnumExample.ValueA"); /// } /// </code> /// </example> public static bool Contains<T>(this Enum value, T request) { int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture); int requestAsInt = Convert.ToInt32(request, CultureInfo.InvariantCulture); if (requestAsInt == (valueAsInt & requestAsInt)) { return true; } return false; } } 

枚举本身必须用FlagsAttribute装饰

 [Flags] public enum EnumExample { ValueA = 1, ValueB = 2, ValueC = 4, ValueD = 8, Combi = ValueA | ValueB } 

某些版本的.NET框架不支持Enum.GetValues 。 这是思路2.0的一个很好的解决方法:Compact Framework中的Enum.GetValues :

 public List<Enum> GetValues(Enum enumeration) { List<Enum> enumerations = new List<Enum>(); foreach (FieldInfo fieldInfo in enumeration.GetType().GetFields( BindingFlags.Static | BindingFlags.Public)) { enumerations.Add((Enum)fieldInfo.GetValue(enumeration)); } return enumerations; } 

与任何涉及reflection的代码一样,您应该采取措施确保只运行一次,并将结果caching起来。

我认为这比其他build议更有效率,因为每次有循环时都不会调用GetValues() 。 它也更简洁。 如果Suit不是enum ,那么您将得到编译时错误,而不是运行时exception。

 EnumLoop<Suit>.ForEach((suit) => { DoSomethingWith(suit); }); 

EnumLoop有这个完全通用的定义:

 class EnumLoop<Key> where Key : struct, IConvertible { static readonly Key[] arr = (Key[])Enum.GetValues(typeof(Key)); static internal void ForEach(Action<Key> act) { for (int i = 0; i < arr.Length; i++) { act(arr[i]); } } } 

为什么没有人使用Cast<T>

 var suits = Enum.GetValues(typeof(Suit)).Cast<Suit>(); 

你去IEnumerable<Suit>

你不会在Silverlight中获得Enum.GetValues()

原创博客发布者Einar Ingebrigtsen :

 public class EnumHelper { public static T[] GetValues<T>() { Type enumType = typeof(T); if (!enumType.IsEnum) { throw new ArgumentException("Type '" + enumType.Name + "' is not an enum"); } List<T> values = new List<T>(); var fields = from field in enumType.GetFields() where field.IsLiteral select field; foreach (FieldInfo field in fields) { object value = field.GetValue(enumType); values.Add((T)value); } return values.ToArray(); } public static object[] GetValues(Type enumType) { if (!enumType.IsEnum) { throw new ArgumentException("Type '" + enumType.Name + "' is not an enum"); } List<object> values = new List<object>(); var fields = from field in enumType.GetFields() where field.IsLiteral select field; foreach (FieldInfo field in fields) { object value = field.GetValue(enumType); values.Add(value); } return values.ToArray(); } } 

只是添加我的解决scheme,它在紧凑的框架(3.5)中工作,并支持编译时的types检查:

 public static List<T> GetEnumValues<T>() where T : new() { T valueType = new T(); return typeof(T).GetFields() .Select(fieldInfo => (T)fieldInfo.GetValue(valueType)) .Distinct() .ToList(); } public static List<String> GetEnumNames<T>() { return typeof (T).GetFields() .Select(info => info.Name) .Distinct() .ToList(); } 

– 如果有人知道如何摆脱T valueType = new T() ,我很乐意看到一个解决scheme。

一个电话会看起来像这样:

 List<MyEnum> result = Utils.GetEnumValues<MyEnum>(); 

我想你可以使用

 Enum.GetNames(Suit) 
 public void PrintAllSuits() { foreach(string suit in Enum.GetNames(typeof(Suits))) { Console.WriteLine(suit); } } 
 foreach (Suit suit in Enum.GetValues(typeof(Suit))) { } 

我听到一些含糊的谣言,说这个速度太慢了。 有人知道吗? – 猎户座爱德华兹10年10月15日在1:31 7

我认为cachingarrays会大大加快速度。 看起来你每次都得到一个新的数组(通过reflection)。 而是:

 Array enums = Enum.GetValues(typeof(Suit)); foreach (Suit suitEnum in enums) { DoSomething(suitEnum); } 

ja至less快一点,ja?

我要把我的两便士扔进去,只要把我通过一个非常简单的扩展的最好的答案结合起来

 public static class EnumExtensions { /// <summary> /// Gets all items for an enum value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">The value.</param> /// <returns></returns> public static IEnumerable<T> GetAllItems<T>(this Enum value) { return (T[])Enum.GetValues(typeof (T)); } } 

干净简单,@ Jeppe-Stig-Nielsen的评论很快。

我使用ToString()然后分裂和parsing标志中的吐数组。

 [Flags] public enum ABC { a = 1, b = 2, c = 4 }; public IEnumerable<ABC> Getselected (ABC flags) { var values = flags.ToString().Split(','); var enums = values.Select(x => (ABC)Enum.Parse(typeof(ABC), x.Trim())); return enums; } ABC temp= ABC.a | ABC.b; var list = getSelected (temp); foreach (var item in list) { Console.WriteLine(item.ToString() + " ID=" + (int)item); } 

三种方式:

 1. Enum.GetValues(type) //since .NET 1.1, not in silverlight or compact framewok 2. type.GetEnumValues() //only on .NET 4 and above 3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) //works everywhere 

不知道为什么在types实例上引入了GetEnumValues ,它对我来说根本不可读。


有一个像Enum<T>这样的辅助类对我来说是最具可读性和令人难忘的:

 public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible { public static IEnumerable<T> GetValues() { return (T[])Enum.GetValues(typeof(T)); } public static IEnumerable<string> GetNames() { return Enum.GetNames(typeof(T)); } } 

现在你打电话给:

 Enum<Suit>.GetValues(); //or Enum.GetValues(typeof(Suit)); //pretty consistent style 

如果性能很重要的话,也可以使用caching,但我不认为这是一个问题

 public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible { //lazily loaded static T[] values; static string[] names; public static IEnumerable<T> GetValues() { return values ?? (values = (T[])Enum.GetValues(typeof(T))); } public static IEnumerable<string> GetNames() { return names ?? (names = Enum.GetNames(typeof(T))); } } 

有两种方法来迭代Enum

 1. var values = Enum.GetValues(typeof(myenum)) 2. var values = Enum.GetNames(typeof(myenum)) 

第一个会给你在一个object的数组forms的值,第二个会给你的值forms的String数组。

foreach循环中使用它如下:

 foreach(var value in values) { //Do operations here } 

我不认为这个更好,甚至更好,只是提出另一个解决scheme。

如果枚举值范围严格从0到n – 1,一个通用的select:

 public void EnumerateEnum<T>() { int length = Enum.GetValues(typeof(T)).Length; for (var i = 0; i < length; i++) { var @enum = (T)(object)i; } } 

如果枚举值是连续的,你可以提供枚举的第一个和最后一个元素,那么:

 public void EnumerateEnum() { for (var i = Suit.Spade; i <= Suit.Diamond; i++) { var @enum = i; } } 

但是这不是严格的枚举,只是循环。 第二种方法比任何其他方法快得多,尽pipe…

如果你需要速度和types检查在构build和运行时,这个辅助方法比使用LINQ来投射每个元素更好:

 public static T[] GetEnumValues<T>() where T : struct, IComparable, IFormattable, IConvertible { if (typeof(T).BaseType != typeof(Enum)) { throw new ArgumentException(string.Format("{0} is not of type System.Enum", typeof(T))); } return Enum.GetValues(typeof(T)) as T[]; } 

你可以像下面一样使用它:

 static readonly YourEnum[] _values = GetEnumValues<YourEnum>(); 

当然你可以返回IEnumerable<T> ,但是这里没有任何东西给你买东西。

这里是为DDL创buildselect选项的工作示例

 var resman = ViewModelResources.TimeFrame.ResourceManager; ViewBag.TimeFrames = from MapOverlayTimeFrames timeFrame in Enum.GetValues(typeof(MapOverlayTimeFrames)) select new SelectListItem { Value = timeFrame.ToString(), Text = resman.GetString(timeFrame.ToString()) ?? timeFrame.ToString() }; 
 foreach (Suit suit in Enum.GetValues(typeof(Suit))) { } 

(目前接受的答案有一个我不认为需要的演员(尽pipe我可能是错的)。)

这个问题出现在“ C#Step by Step 2013 ”的第10章中

作者使用一个双重的for循环遍历一对枚举器(创build一个完整的卡片组):

 class Pack { public const int NumSuits = 4; public const int CardsPerSuit = 13; private PlayingCard[,] cardPack; public Pack() { this.cardPack = new PlayingCard[NumSuits, CardsPerSuit]; for (Suit suit = Suit.Clubs; suit <= Suit.Spades; suit++) { for (Value value = Value.Two; value <= Value.Ace; value++) { cardPack[(int)suit, (int)value] = new PlayingCard(suit, value); } } } } 

在这种情况下, SuitValue都是枚举:

 enum Suit { Clubs, Diamonds, Hearts, Spades } enum Value { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace} 

并且PlayingCard是具有定义的SuitValue的卡对象:

 class PlayingCard { private readonly Suit suit; private readonly Value value; public PlayingCard(Suit s, Value v) { this.suit = s; this.value = v; } } 

我知道这有点乱,但是如果你是单行者的粉丝,这里是一个:

 ((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i)); 

将枚举转换为可以交互的东西的简单通用方法:

 public static Dictionary<int, string> ToList<T>() where T : struct { return ((IEnumerable<T>)Enum .GetValues(typeof(T))) .ToDictionary( item => Convert.ToInt32(item), item => item.ToString()); } 

接着:

 var enums = EnumHelper.ToList<MyEnum>(); 

如果你知道types是一个enum ,但是你不知道在编译时确切的types是什么?

 public class EnumHelper { public static IEnumerable<T> GetValues<T>() { return Enum.GetValues(typeof(T)).Cast<T>(); } public static IEnumerable getListOfEnum(Type type) { MethodInfo getValuesMethod = typeof(EnumHelper).GetMethod("GetValues").MakeGenericMethod(type); return (IEnumerable)getValuesMethod.Invoke(null, null); } } 

getListOfEnum方法使用reflection来获取任何枚举types,并返回所有枚举值的IEnumerable

用法:

 Type myType = someEnumValue.GetType(); IEnumerable resultEnumerable = getListOfEnum(myType); foreach (var item in resultEnumerable) { Console.WriteLine(String.Format("Item: {0} Value: {1}",item.ToString(),(int)item)); } 

你也可以使用reflection直接绑定到枚举的公共静态成员:

 typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static) .ToList().ForEach(x => DoSomething(x.Name)); 

向您的类添加方法public static IEnumerable<T> GetValues<T>()

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

调用并传递你的枚举,现在你可以遍历它使用foreach

  public static void EnumerateAllSuitsDemoMethod() { // custom method var foos = GetValues<Suit>(); foreach (var foo in foos) { // Do something } } 

enumtypes被称为“枚举types”不是因为它们是“枚举”值(它们不是)的容器,而是因为它们是通过枚举该types的variables的可能值来定义的。

(实际上,比这更复杂 – 枚举types被认为是一个“基础”整数types,这意味着每个枚举值对应于一个整数值(这通常是隐含的,但可以手动指定)。这样就可以将任何types的整数join枚举variables中,即使它不是“已命名”的值)。

顾名思义,可以使用GetNames方法来检索作为枚举值名称的string数组。