[c#] 我如何迭代枚举?



Answers

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

你如何enum C#中的enum

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

public enum Suit 
{
    Spades,
    Hearts,
    Clubs,
    Diamonds
}

public void EnumerateAllSuitsDemoMethod() 
{
    foreach (Suit suit in Suit) 
    {
        DoSomething(suit);
    }
}

并给出以下编译时错误:

“西装”是一种“类型”,但用作“变量”

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




向你的类添加方法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
     }
 }



只需添加我的解决方案,该解决方案在紧凑框架(3.5)中工作,并在编译时支持类型检查:

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() ,我很乐意看到一个解决方案。

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

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



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



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

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

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



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

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



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

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

你去IEnumerable<Suit>




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

(实际上,这比这更复杂 - 枚举类型被认为具有“底层”整数类型,这意味着每个枚举值对应于一个整数值(这通常是隐含的,但可以手动指定)。这样可以将任何类型的整数填充到枚举变量中,即使它不是“已命名”值。)

顾名思义, System.Enum.GetNames方法可用于检索作为枚举值名称的字符串数组。

编辑:应该建议改为System.Enum.GetValues方法。 哎呀。




我使用ToString()然后拆分并解析标志中的吐出数组。

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



这里是为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()
      };



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

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的评论快速。




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

如果枚举值范围严格从0到n - 1,则可以使用一个通用的替代方法:

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

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




某些版本的.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代码一样,您应该采取措施确保它只运行一次并且结果被缓存。






Related