如何在C＃中枚举枚举？

你怎么能enum C＃中的enum ？

例如，以下代码无法编译：

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

并给出以下编译时错误：

‘Suit’是’type’，但用作’变量’

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

Answer 1

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

Answer 2

在我看来，你真的想要打印每个枚举的名称，而不是值。 在这种情况下， 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()); } } 

Answer 3

我做了一些扩展以便轻松使用枚举，也许有人可以使用它…

 public static class EnumExtensions { /// 
 /// Gets all items for an enum value. /// 
 ///  /// The value. ///  public static IEnumerable GetAllItems(this Enum value) { foreach (object item in Enum.GetValues(typeof(T))) { yield return (T)item; } } /// 
 /// Gets all items for an enum type. /// 
 ///  /// The value. ///  public static IEnumerable GetAllItems() where T : struct { foreach (object item in Enum.GetValues(typeof(T))) { yield return (T)item; } } /// 
 /// Gets all combined items from an enum value. /// 
 ///  /// The value. ///  ///  /// Displays ValueA and ValueB. ///  /// EnumExample dummy = EnumExample.Combi; /// foreach (var item in dummy.GetAllSelectedItems()) /// { /// Console.WriteLine(item); /// } ///  ///  public static IEnumerable GetAllSelectedItems(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; } } } /// 
 /// Determines whether the enum value contains a specific value. /// 
 /// The value. /// The request. ///  /// true if value contains the specified value; otherwise, false. ///  ///  ///  /// EnumExample dummy = EnumExample.Combi; /// if (dummy.Contains(EnumExample.ValueA)) /// { /// Console.WriteLine("dummy contains EnumExample.ValueA"); /// } ///  ///  public static bool Contains(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 } 

Answer 4

某些版本的.NET框架不支持Enum.GetValues 。 以下是Ideas 2.0中的一个很好的解决方法：Compact Framework中的Enum.GetValues ：

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

与涉及reflection的任何代码一样，您应该采取措施确保它只运行一次并缓存结果。

Answer 5

我认为这比其他建议更有效，因为每次循环时都不会调用GetValues() 。 它也更简洁。 如果Suit不是enum则会出现编译时错误，而不是运行时exception。

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

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

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

Answer 6

为什么没有人使用Cast ？

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

你去IEnumerable 。

Answer 7

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

Einar Ingebrigtsen的原始博文 ：

 public class EnumHelper { public static T[] GetValues() { Type enumType = typeof(T); if (!enumType.IsEnum) { throw new ArgumentException("Type '" + enumType.Name + "' is not an enum"); } List values = new List(); 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 

Answer 8

只是添加我的解决方案，它在紧凑的框架（3.5）中工作，并支持在编译时进行类型检查：

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

– 如果有人知道如何摆脱T valueType = new T() ，我很乐意看到解决方案。

一个电话看起来像这样：

 List result = Utils.GetEnumValues(); 

Answer 9

我想你可以用

 Enum.GetNames(Suit) 

Answer 10

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

Answer 11

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

我听到一些含糊不清的谣言说这种情况非常缓慢。 谁知道？ – 猎户座爱德华兹08年10月15日1:31 7

我认为缓存arrays会大大加快它的速度。 看起来你每次都会得到一个新arrays（通过reflection）。 而是：

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

这至少要快一点，ja？

Answer 12

三种方式：

 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 

不确定为什么GetEnumValues在类型实例上引入，它对我来说根本不是很可读。

---

像Enum这样的助手类对我来说是最具可读性和难忘性的：

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

现在你打电话：

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

如果性能很重要，也可以使用某种缓存，但我不认为这根本就是一个问题

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

Answer 13

我将把我的两便士扔进去，只需将最顶层的答案结合在一起，我就可以通过一个非常简单的扩展

 public static class EnumExtensions { /// 
 /// Gets all items for an enum value. /// 
 ///  /// The value. ///  public static IEnumerable GetAllItems(this Enum value) { return (T[])Enum.GetValues(typeof (T)); } } 

干净简单，并由@ Jeppe-Stig-Nielsen快速评论。

Answer 14

我使用ToString（）然后拆分并解析标志中的spit数组。

 [Flags] public enum ABC { a = 1, b = 2, c = 4 }; public IEnumerable 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); } 

Answer 15

迭代Enum有两种方法：

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

第一个将在object数组中为您提供表单中的值，第二个将以String数组的forms为您提供值。

在foreach循环中使用它如下：

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

Answer 16

我不认为这更好，甚至更好，只是陈述另一种解决方案。

如果枚举值严格范围从0到n – 1，则通用替代方法：

 public void EnumerateEnum() { 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; } } 

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

Answer 17

如果在构建和运行时需要速度和类型检查，这个辅助方法比使用LINQ强制转换每个元素更好：

 public static T[] GetEnumValues() 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(); 

当然你可以返回IEnumerable ，但是这里没有你买的东西。

Answer 18

这是为DDL创建选择选项的工作示例

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

Answer 19

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

（目前接受的答案有一个我认为不需要的演员（尽管我可能错了）。）

Answer 20

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

作者使用双循环来迭代一对枚举器（以创建一副完整的卡片）：

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

Answer 21

我知道它有点乱，但如果你是单行的粉丝，这里有一个：

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

Answer 22

将枚举转换为可以交互的内容的简单通用方法：

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

然后：

 var enums = EnumHelper.ToList(); 

Answer 23

如果您知道类型将是enum ，但您不知道编译时的确切类型是什么？

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

方法getListOfEnum使用reflection来获取任何枚举类型并返回所有枚举值的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)); } 

Answer 24

添加方法public static IEnumerable GetValues()到你的类，比如

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

调用并传递你的枚举，现在你可以使用foreach迭代它

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

Answer 25

您还可以使用reflection直接绑定到枚举的公共静态成员：

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

Answer 26

enum类型被称为“枚举类型”，不是因为它们是“枚举”值（它们不是）的容器，而是因为它们是通过枚举该类型变量的可能值来定义的。

（实际上，这有点复杂 – 枚举类型被认为具有“底层”整数类型，这意味着每个枚举值对应一个整数值（这通常是隐式的，但可以手动指定）.C＃是设计的在某种程度上，你可以将任何类型的整数填充到枚举变量中，即使它不是“命名”值。）

System.Enum.GetNames方法可用于检索字符串数组，这些字符串是枚举值的名称，顾名思义。

编辑：应该建议使用System.Enum.GetValues方法。 哎呀。