你怎么能用enum
C#枚举一下?
例如,以下代码无法编译:
public enum Suit
{
Spades,
Hearts,
Clubs,
Diamonds
}
public void EnumerateAllSuitsDemoMethod()
{
foreach (Suit suit in Suit)
{
DoSomething(suit);
}
}
并给出以下编译时错误:
'Suit'是'type',但用作'变量'
Suit
关键字失败,第二个关键字失败.
foreach (Suit suit in (Suit[]) Enum.GetValues(typeof(Suit))) { }
注意:强制转换(Suit[])
不是必需的,但确实使代码快0.5 ns.
在我看来,你真的想要打印每个枚举的名称,而不是值.在这种情况下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 { ////// 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. /// public static IEnumerable/// EnumExample dummy = EnumExample.Combi; /// foreach (var item in dummy.GetAllSelectedItems
///()) /// { /// Console.WriteLine(item); /// } /// 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 . ////// public static bool Contains/// EnumExample dummy = EnumExample.Combi; /// if (dummy.Contains
///(EnumExample.ValueA)) /// { /// Console.WriteLine("dummy contains EnumExample.ValueA"); /// } /// (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
.以下是Ideas 2.0中的一个很好的解决方法:Compact Framework中的Enum.GetValues:
public Enum[] GetValues(Enum enumeration) { FieldInfo[] fields = enumeration.GetType().GetFields(BindingFlags.Static | BindingFlags.Public); Enum[] enumerations = new Enum[fields.Length]; for (var i = 0; i < fields.Length; i++) enumerations[i] = (Enum) fields[i].GetValue(enumeration); return enumerations; }
与涉及反射的任何代码一样,您应该采取措施确保它只运行一次并缓存结果.
为什么没有人使用Cast
?
var suits = Enum.GetValues(typeof(Suit)).Cast();
你去那里IEnumerable
.
我认为这比其他建议更有效,因为GetValues()
每次循环时都不会调用它.它也更简洁.并且如果Suit
不是,则会出现编译时错误,而不是运行时异常enum
.
EnumLoop.ForEach((suit) => { DoSomethingWith(suit); });
EnumLoop
有这个完全通用的定义:
class EnumLoopwhere 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]); } } }
你不会进入Enum.GetValues()
Silverlight.
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
只是添加我的解决方案,它在紧凑的框架(3.5)中工作,并支持在编译时进行类型检查:
public static ListGetEnumValues () 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()
,我很乐意看到解决方案.
一个电话看起来像这样:
Listresult = Utils.GetEnumValues ();
我想你可以用
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))) { }我听到一些含糊不清的谣言说这种情况非常缓慢.谁知道? - 猎户座爱德华兹08年10月15日1:31 7
我认为缓存阵列会大大加快它的速度.看起来你每次都会得到一个新阵列(通过反射).而是:
Array enums = Enum.GetValues(typeof(Suit)); foreach (Suit suitEnum in enums) { DoSomething(suitEnum); }
这至少要快一点,ja?
我将把我的两便士扔进去,只需将最重要的答案结合在一起,我就可以通过一个非常简单的扩展
public static class EnumExtensions { ////// Gets all items for an enum value. /// ////// The value. /// public static IEnumerable GetAllItems (this T value) where T : Enum { return (T[])Enum.GetValues(typeof (T)); } }
干净简单,由@ Jeppe-Stig-Nielsen快速评论.
三种方式:
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 Enumwhere 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 Enumwhere 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))); } }
我使用ToString()然后拆分并解析标志中的spit数组.
[Flags] public enum ABC { a = 1, b = 2, c = 4 }; public IEnumerableGetselected (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); }
迭代有两种方法Enum
:
1. var values = Enum.GetValues(typeof(myenum)) 2. var values = Enum.GetNames(typeof(myenum))
第一个将在数组中object
给出表单中的值,第二个将以数组形式给出值String
.
在foreach
循环中使用它如下:
foreach(var value in values) { //Do operations here }
如果枚举值严格范围从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; } }
但这不是严格的枚举,只是循环.第二种方法比任何其他方法快得多......
如果在构建和运行时需要速度和类型检查,这个辅助方法比使用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
,但这里没有给你买.
这是为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() };
foreach (Suit suit in Enum.GetValues(typeof(Suit))) { }
(目前接受的答案有一个我认为不需要的演员(尽管我可能错了).)
这个问题出现在" 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; } }
我知道它有点乱,但如果你是单行的粉丝,这里有一个:
((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i));
将枚举转换为可以交互的内容的简单通用方法:
public static DictionaryToList () where T : struct { return ((IEnumerable )Enum .GetValues(typeof(T))) .ToDictionary( item => Convert.ToInt32(item), item => item.ToString()); }
然后:
var enums = EnumHelper.ToList();
如果您知道类型将是一个enum
,但是您不知道编译时的确切类型是什么?
public class EnumHelper { public static IEnumerableGetValues () { 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
使用反射来获取任何枚举类型并返回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)); }
public static IEnumerable
向您的班级添加方法,例如
public static IEnumerableGetValues () { return Enum.GetValues(typeof(T)).Cast (); }
调用并传递您的枚举,现在您可以使用 foreach
public static void EnumerateAllSuitsDemoMethod() { // custom method var foos = GetValues(); foreach (var foo in foos) { // Do something } }