Làm thế nào để liệt kê một enum

Làm thế nào bạn có thể liệt kê một enumtrong C #?

Ví dụ: đoạn mã sau không biên dịch:

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

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

Và nó đưa ra lỗi thời gian biên dịch sau:

'Suit' là 'loại' nhưng được sử dụng như 'biến'

Nó thất bại về Suittừ khóa, cái thứ hai.

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

Lưu ý : Việc truyền vào (Suit[])không thực sự cần thiết, nhưng nó làm cho mã 0,5 ns nhanh hơn .

Có vẻ như tôi thực sự muốn in ra tên của từng enum, hơn là các giá trị. Trong trường hợp đó Enum.GetNames()dường như là cách tiếp cận đúng.

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

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

Nhân tiện, tăng giá trị không phải là một cách tốt để liệt kê các giá trị của một enum. Bạn nên làm điều này thay vào đó.

Tôi sẽ sử dụng Enum.GetValues(typeof(Suit))thay thế.

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

public void PrintAllSuits()
{
    foreach (var suit in Enum.GetValues(typeof(Suits)))
    {
        System.Console.WriteLine(suit.ToString());
    }
}

Tôi đã thực hiện một số phần mở rộng để sử dụng enum dễ dàng. Có lẽ ai đó có thể sử dụng nó ...

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

Bản thân enum phải được trang trí với FlagsAttribution :

[Flags]
public enum EnumExample
{
    ValueA = 1,
    ValueB = 2,
    ValueC = 4,
    ValueD = 8,
    Combi = ValueA | ValueB
}

Một số phiên bản của .NET framework không hỗ trợ Enum.GetValues. Đây là một cách giải quyết tốt từ Ý tưởng 2.0: Enum.GetValues ​​trong Compact Framework :

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

Như với bất kỳ mã nào liên quan đến sự phản chiếu , bạn nên thực hiện các bước để đảm bảo nó chỉ chạy một lần và kết quả được lưu trữ.

Sử dụng Cast<T>:

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

Có bạn đi , IEnumerable<Suit>.

Tôi nghĩ rằng điều này hiệu quả hơn các đề xuất khác vì GetValues()không được gọi mỗi khi bạn có một vòng lặp. Nó cũng súc tích hơn. Và bạn gặp lỗi thời gian biên dịch, không phải là ngoại lệ thời gian chạy nếu Suitkhông phải là enum.

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

EnumLoop có định nghĩa hoàn toàn chung chung này:

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

Bạn sẽ không nhận được Enum.GetValues()trong Silverlight .

Bài viết gốc của 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();
    }
}

Giải pháp của tôi hoạt động trong .NET Compact Framework (3.5) và hỗ trợ kiểm tra kiểu tại thời gian biên dịch :

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

• Nếu bất cứ ai biết cách thoát khỏi T valueType = new T(), tôi rất vui khi thấy một giải pháp.

Một cuộc gọi sẽ như thế này:

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

Tôi nghĩ bạn có thể sử dụng

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

Tôi đã nghe những tin đồn mơ hồ rằng điều này rất chậm. Có ai biết không? - Orion Edwards ngày 15 tháng 10 năm 08 lúc 1:31 7

Tôi nghĩ rằng bộ nhớ đệm mảng sẽ tăng tốc đáng kể. Dường như bạn đang nhận được một mảng mới (thông qua sự phản chiếu) mỗi lần. Hơn:

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

Đó là nhanh hơn một chút, ja?

Ba cách:

1. Enum.GetValues(type) // Kể từ .NET 1.1, không có trong Silverlight hoặc .NET Compact Framework
2. type.GetEnumValues() // Chỉ trên .NET 4 trở lên
3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) // Hoạt động ở mọi nơi

Tôi không chắc tại sao GetEnumValuesđược giới thiệu trên các trường hợp loại. Nó không phải là rất dễ đọc đối với tôi.

Có một lớp người trợ giúp như thế Enum<T>là điều dễ đọc và đáng nhớ nhất đối với tôi:

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

Bây giờ bạn gọi:

Enum<Suit>.GetValues();

// Or
Enum.GetValues(typeof(Suit)); // Pretty consistent style

Người ta cũng có thể sử dụng một số loại bộ nhớ đệm nếu hiệu suất có vấn đề, nhưng tôi không hy vọng đây sẽ là một vấn đề.

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

Chỉ bằng cách kết hợp các câu trả lời hàng đầu, tôi đã tạo ra một phần mở rộng rất đơn giản:

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 T value) where T : Enum
    {
        return (T[])Enum.GetValues(typeof (T));
    }
}

Nó sạch sẽ, đơn giản và, bởi nhận xét của @ Jeppe-Stig-Nielsen, nhanh chóng.

Có hai cách để lặp lại một Enum:

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

Cái đầu tiên sẽ cung cấp cho bạn các giá trị dưới dạng trên một mảng ** object** s và thứ hai sẽ cung cấp cho bạn các giá trị dưới dạng một mảng ** String** s.

Sử dụng nó trong một foreachvòng lặp như dưới đây:

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

Tôi sử dụng ToString () sau đó phân tách và phân tích mảng nhổ trong cờ.

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

Tôi không giữ quan điểm này là tốt hơn, hoặc thậm chí là tốt. Tôi chỉ nêu một giải pháp khác.

Nếu giá trị enum nằm trong phạm vi từ 0 đến n - 1, thì một thay thế chung là:

public void EnumerateEnum<T>()
{
    int length = Enum.GetValues(typeof(T)).Length;
    for (var i = 0; i < length; i++)
    {
        var @enum = (T)(object)i;
    }
}

Nếu các giá trị enum tiếp giáp nhau và bạn có thể cung cấp phần tử đầu tiên và cuối cùng của enum, thì:

public void EnumerateEnum()
{
    for (var i = Suit.Spade; i <= Suit.Diamond; i++)
    {
        var @enum = i;
    }
}

Nhưng đó không phải là liệt kê nghiêm ngặt, chỉ cần lặp đi lặp lại. Phương pháp thứ hai nhanh hơn nhiều so với bất kỳ phương pháp nào khác mặc dù ...

Nếu bạn cần kiểm tra tốc độ và kiểu lúc xây dựng và chạy, phương thức trợ giúp này tốt hơn là sử dụng LINQ để truyền từng phần tử:

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

Và bạn có thể sử dụng nó như dưới đây:

static readonly YourEnum[] _values = GetEnumValues<YourEnum>();

Tất nhiên bạn có thể trở lại IEnumerable<T>, nhưng điều đó mua cho bạn không có gì ở đây.

Dưới đây là một ví dụ hoạt động về việc tạo các tùy chọn chọn cho 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âu trả lời được chấp nhận hiện tại có một dàn diễn viên mà tôi không nghĩ là cần thiết (mặc dù tôi có thể sai).)

Câu hỏi này xuất hiện trong Chương 10 của " C # Từng bước 2013 "

Tác giả sử dụng một vòng lặp đôi để lặp qua một cặp Số liệu (để tạo một bộ bài đầy đủ):

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

Trong trường hợp này, Suitvà Valuecả hai bảng liệt kê:

enum Suit { Clubs, Diamonds, Hearts, Spades }
enum Value { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace}

và PlayingCardlà một đối tượng thẻ có xác định Suitvà Value:

class PlayingCard
{
    private readonly Suit suit;
    private readonly Value value;

    public PlayingCard(Suit s, Value v)
    {
        this.suit = s;
        this.value = v;
    }
}

Tôi biết nó hơi lộn xộn, nhưng nếu bạn là fan hâm mộ của một lớp lót, thì đây là một:

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

Điều gì sẽ xảy ra nếu bạn biết loại sẽ là một enum, nhưng bạn không biết loại chính xác là gì trong thời gian biên dịch?

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

Phương thức getListOfEnumsử dụng sự phản chiếu để lấy bất kỳ loại enum nào và trả về một IEnumerabletrong tất cả các giá trị enum.

Sử dụng:

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

Một cách đơn giản và chung chung để chuyển đổi một enum thành thứ gì đó bạn có thể tương tác:

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

Và sau đó:

var enums = EnumHelper.ToList<MyEnum>();

Thêm phương thức public static IEnumerable<T> GetValues<T>()vào lớp của bạn, như:

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

Gọi và vượt qua enum của bạn. Bây giờ bạn có thể lặp qua nó bằng cách sử dụng foreach:

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

enumcác loại được gọi là "kiểu liệt kê" không phải vì chúng là các thùng chứa "liệt kê" các giá trị (mà chúng không có), mà bởi vì chúng được xác định bằng cách liệt kê các giá trị có thể cho một biến của loại đó.

(Trên thực tế, điều đó phức tạp hơn một chút - các loại enum được coi là có loại số nguyên "cơ bản", có nghĩa là mỗi giá trị enum tương ứng với một giá trị số nguyên (điều này thường ẩn, nhưng có thể được chỉ định thủ công). theo cách để bạn có thể nhét bất kỳ số nguyên của loại đó vào biến enum, ngay cả khi đó không phải là giá trị "được đặt tên".)

Các phương pháp System.Enum.GetNames có thể được sử dụng để lấy một mảng các chuỗi đó là tên của các giá trị enum, như tên gọi của nó.

EDIT: Nên đã đề xuất phương thức System.Enum.GetValues thay thế. Giáo sư.

Tôi đã thử nhiều cách và nhận được kết quả từ mã này:

Để nhận danh sách int từ enum, hãy sử dụng như sau. Nó hoạt động!

List<int> listEnumValues = new List<int>();
YourEnumType[] myEnumMembers = (YourEnumType[])Enum.GetValues(typeof(YourEnumType));
foreach ( YourEnumType enumMember in myEnumMembers)
{
    listEnumValues.Add(enumMember.GetHashCode());
}

Ngoài ra, bạn có thể liên kết với các thành viên tĩnh công khai của enum bằng cách sử dụng sự phản chiếu:

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

Nếu bạn có:

enum Suit
{
   Spades,
   Hearts,
   Clubs,
   Diamonds
}

Điều này:

foreach (var e in Enum.GetValues(typeof(Suit)))
{
    Console.WriteLine(e.ToString() + " = " + (int)e);
}

Sẽ xuất:

Spades = 0
Hearts = 1
Clubs = 2
Diamonds = 3

Cách chung của LINQ :

    public static Dictionary<int, string> ToList<T>() where T : struct =>
        ((IEnumerable<T>)Enum.GetValues(typeof(T))).ToDictionary(value => Convert.ToInt32(value), value => value.ToString());

Sử dụng:

        var enums = ToList<Enum>();