c#類 如何在C#中枚舉枚舉?




13 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());
    }
}
c# this用法

你怎麼能enum C#中的enum

例如,以下代碼無法編譯:

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

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

並給出以下編譯時錯誤:

'Suit'是'type',但用作'變量'

它在Suit關鍵字上失敗,第二個。




某些版本的.NET框架不支持Enum.GetValues 。 以下是Ideas 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任何代碼一樣,您應該採取措施確保它只運行一次並緩存結果。




為什麼沒有人使用Cast<T>

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

你去IEnumerable<Suit>




只是添加我的解決方案,它在緊湊的框架(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);
    }
}



三種方式:

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

如果性能很重要,也可以使用某種緩存,但我不認為這根本就是一個問題

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



我使用ToString()然後拆分並解析標誌中的spit數組。

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



我不認為這更好,甚至更好,只是陳述另一種解決方案。

如果枚舉值嚴格範圍從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;
    }
}

但這不是嚴格的枚舉,只是循環。 第二種方法比任何其他方法快得多......




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



這個問題出現在“ 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);
            }
        }
    }
}

在這種情況下, 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>();



添加方法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
     }
 }



enum類型被稱為“枚舉類型”,不是因為它們是“枚舉”值(它們不是)的容器,而是因為它們是通過枚舉該類型變量的可能值來定義的。

(實際上,這有點複雜 - 枚舉類型被認為具有“底層”整數類型,這意味著每個枚舉值對應一個整數值(這通常是隱式的,但可以手動指定).C#是設計的在某種程度上,你可以將任何類型的整數填充到枚舉變量中,即使它不是“命名”值。)

System.Enum.GetNames方法可用於檢索字符串數組,這些字符串是枚舉值的名稱,顧名思義。

編輯:應該建議使用System.Enum.GetValues方法。 哎呀。




Related