我如何列举一个枚举？
你怎么能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); } } } }
在这种情况下， Suit和Value都是枚举：
enum Suit { Clubs, Diamonds, Hearts, Spades } enum Value { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace}
并且PlayingCard是具有定义的Suit和Value的卡对象：
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数组。
