Как перечислить перечисление?

Как вы можете перечислить enum в С#?

например. следующий код не компилируется:

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

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

И дает следующую ошибку времени компиляции:

"Костюм" - это "тип", но используется как "переменная"

Не выполняется ключевое слово Suit, второе.

2854
задан Ian Boyd 19 сент. '08 в 23:34
источник поделиться
26 ответов
foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
    // ...
}
3586
ответ дан jop 19 сент. '08 в 23:37
источник поделиться

Мне кажется, что вы действительно хотите распечатать имена каждого перечисления, а не значения. В этом случае 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());
    }
}
510
ответ дан Haacked 19 сент. '08 в 23:39
источник поделиться

Я сделал несколько расширений для простого использования перечисления, возможно, кто-то может его использовать...

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

Само перечисление должно быть украшено FlagsAttribute

[Flags]
public enum EnumExample
{
    ValueA = 1,
    ValueB = 2,
    ValueC = 4,
    ValueD = 8,
    Combi = ValueA | ValueB
}
263
ответ дан bob 03 июня '09 в 15:03
источник поделиться

Некоторые версии платформы .NET не поддерживают Enum.GetValues. Здесь хорошее обходное решение от Идеи 2.0: Enum.GetValues ​​в Compact Framework:

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, вы должны предпринять шаги, чтобы гарантировать, что он запускается только один раз, и результаты кэшируются.

137
ответ дан Ekevoo 03 сент. '09 в 21:48
источник поделиться

Я думаю, что это более эффективно, чем другие предложения, потому что GetValues() не вызывается каждый раз, когда у вас есть цикл. Это также более красноречиво. И вы получаете ошибку времени компиляции, а не исключение во время выполнения, если Suit не является enum.

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

EnumLoop имеет это полностью общее определение:

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]);
        }
    }
}
79
ответ дан James 02 февр. '12 в 16:36
источник поделиться

Почему никто не использует Cast<T>?

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

Там вы идете IEnumerable<Suit>.

66
ответ дан sircodesalot 17 марта '13 в 7:15
источник поделиться

Вы не получите Enum.GetValues() в Silverlight.

Отправка оригинального сообщения от 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();
    }
}
64
ответ дан Aubrey Taylor 17 нояб. '10 в 4:29
источник поделиться

Просто добавьте мое решение, которое работает в компактной структуре (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>();
49
ответ дан Mallox 07 июля '10 в 16:37
источник поделиться

Я думаю, вы можете использовать

Enum.GetNames(Suit)
43
ответ дан Tom Carr 19 сент. '08 в 23:37
источник поделиться
public void PrintAllSuits()
{
    foreach(string suit in Enum.GetNames(typeof(Suits)))
    {
        Console.WriteLine(suit);
    }
}
42
ответ дан Joshua Drake 20 сент. '08 в 0:05
источник поделиться
foreach (Suit suit in Enum.GetValues(typeof(Suit))) { }

Я слышал смутные слухи, что это существенно медленнее. Кто-нибудь знает? - Орион Edwards 15 окт 2008 в 1:31 7

Я думаю, что кеширование массива значительно ускорит его. Похоже, вы каждый раз получаете новый массив (через отражение). Скорее всего:

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

Это, по крайней мере, немного быстрее, ja?

31
ответ дан Limited Atonement 16 нояб. '09 в 20:19
источник поделиться

Что, черт возьми, я брошу свои два пенсов, просто объединив верхние ответы, которые я объединил, очень простое расширение

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.

20
ответ дан Darkside 15 июня '13 в 11:22
источник поделиться

Я использую 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);
}
19
ответ дан Mickey Perlstein 26 июля '12 в 12:22
источник поделиться

Три способа:

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)));
    }
}
19
ответ дан nawfal 12 авг. '13 в 18:36
источник поделиться

Существует два способа итерации 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
}
16
ответ дан Kylo Ren 22 янв. '16 в 21:50
источник поделиться

Я не считаю, что это лучше или даже хорошо, просто заявив еще одно решение.

Если значения перечислимого диапазона строго от 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;
    }
}

но это не строго перечисление, просто цикл. Второй метод намного быстрее, чем любой другой подход, хотя...

13
ответ дан nawfal 25 янв. '13 в 3:05
источник поделиться

Если вам нужна проверка скорости и типа при сборке и времени выполнения, этот вспомогательный метод лучше, чем использование LINQ для создания каждого элемента:

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

И вы можете использовать его, как показано ниже:

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

Конечно, вы можете вернуть IEnumerable<T>, но вы ничего здесь не покупаете.

13
ответ дан dmihailescu 15 нояб. '13 в 23:13
источник поделиться

вот рабочий пример создания опций выбора для 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()
      };
11
ответ дан jhilden 26 окт. '12 в 0:20
источник поделиться
foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
}

(В текущем принятом ответе есть бросок, который я не думаю (хотя я могу ошибаться).

8
ответ дан matt burns 20 янв. '14 в 13:37
источник поделиться

Этот вопрос появляется в главе 10 " С# Step by Step 2013

Автор использует double for-loop для итерации через пару Enumerators (для создания полной колоды карт):

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;
    }
}
8
ответ дан Ross Gatih 28 июня '15 в 9:12
источник поделиться

Я знаю, что это немного грязно, но если вы поклонник однострочных, вот один из них:

((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i));
7
ответ дан anar khalilov 08 апр. '14 в 18:44
источник поделиться

Простой и общий способ преобразования перечисления в нечто, с которым вы можете взаимодействовать:

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>();
7
ответ дан Gabriel 12 сент. '14 в 21:06
источник поделиться

Что, если вы знаете, что тип будет enum, но вы не знаете, какой именно тип находится во время компиляции?

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

Метод 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));
}
5
ответ дан Slappywag 01 окт. '15 в 13:14
источник поделиться

enum типы называются "перечисляемыми типами" не потому, что они являются контейнерами, которые "перечисляют" значения (которых они не являются), а потому, что они определяются путем перечисления возможных значений для переменной этого типа.

(На самом деле, это немного сложнее, чем типы перечислений, как считается, имеют "базовый" целочисленный тип, что означает, что каждое значение перечисления соответствует целочисленному значению (это обычно неявно, но может быть указано вручную). С# был спроектирован таким образом, чтобы вы могли набить любое целое число этого типа в переменную enum, даже если это не "именованное" значение.)

Метод GetNames можно использовать для извлечения массива строк, которые являются именами значений перечисления, как следует из названия.

0
ответ дан Emily Chen 11 окт. '17 в 7:50
источник поделиться

Также вы можете привязываться к публичным статическим членам перечисления напрямую, используя отражение:

typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static)
    .ToList().ForEach(x => DoSomething(x.Name));
0
ответ дан Termininja 10 янв. '17 в 2:39
источник поделиться

Добавьте метод 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
     }
 }
0
ответ дан MUT 31 марта '17 в 10:08
источник поделиться

Другие вопросы по меткам