Jak wyliczyć wyliczenie

Jak wyliczyć enumw C #?

Np. Poniższy kod się nie kompiluje:

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

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

Daje to następujący błąd czasu kompilacji:

„Kolor” jest „typem”, ale jest używany jak „zmienna”

Nie działa na Suitsłowo kluczowe, drugie.

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

Uwaga : rzutowanie na (Suit[])nie jest absolutnie konieczne, ale przyspiesza kod o 0,5 ns .

Wydaje mi się, że naprawdę chcesz wydrukować nazwy każdego wyliczenia, a nie wartości. W takim przypadku Enum.GetNames()wydaje się to właściwe podejście.

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

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

Nawiasem mówiąc, zwiększanie wartości nie jest dobrym sposobem na wyliczenie wartości wyliczenia. Powinieneś to zrobić zamiast tego.

Użyłbym Enum.GetValues(typeof(Suit))zamiast tego.

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

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

Zrobiłem kilka rozszerzeń dla łatwego użycia enum. Może ktoś może go użyć ...

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

Sam enum musi być ozdobiony FlagsAttribute :

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

Niektóre wersje .NET Framework nie obsługują Enum.GetValues. Oto dobre obejście od Ideas 2.0: Enum.GetValues ​​w 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;
}

Podobnie jak w przypadku każdego kodu, który wymaga refleksji , powinieneś podjąć kroki, aby upewnić się, że działa tylko raz, a wyniki są buforowane.

Użyj Cast<T>:

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

Proszę bardzo IEnumerable<Suit>.

Myślę, że jest to bardziej wydajne niż inne sugestie, ponieważ GetValues()nie jest wywoływane za każdym razem, gdy masz pętlę. Jest również bardziej zwięzły. I pojawia się błąd czasu kompilacji, a nie wyjątek czasu wykonywania, jeśli Suitnie jest enum.

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

EnumLoop ma tę całkowicie ogólną definicję:

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

Nie dostaniesz się Enum.GetValues()w Silverlight .

Oryginalny post na blogu autorstwa Einara Ingebrigtsena :

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

Moje rozwiązanie działa w .NET Compact Framework (3.5) i obsługuje sprawdzanie typów w czasie kompilacji :

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

• Jeśli ktoś wie, jak się go pozbyć T valueType = new T(), chętnie znajdę rozwiązanie.

Połączenie wyglądałoby tak:

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

Myślę, że możesz użyć

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

Słyszałem niejasne plotki, że jest to wyjątkowo powolne. Ktoś wie? - Orion Edwards, 15 października 2008 o 1:31 7

Myślę, że buforowanie tablicy znacznie przyspieszy. Wygląda na to, że za każdym razem otrzymujesz nową tablicę (poprzez odbicie). Raczej:

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

To przynajmniej trochę szybciej, ja?

Trzy drogi:

1. Enum.GetValues(type) // Od .NET 1.1, nie w Silverlight ani .NET Compact Framework
2. type.GetEnumValues() // Tylko w .NET 4 i nowszych
3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) // Działa wszędzie

Nie jestem pewien, dlaczego GetEnumValueszostał wprowadzony w instancjach typu. Dla mnie to wcale nie jest bardzo czytelne.

Posiadanie klasy pomocniczej Enum<T>jest dla mnie najbardziej czytelne i niezapomniane:

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

Teraz dzwonisz:

Enum<Suit>.GetValues();

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

Można również użyć pewnego rodzaju buforowania, jeśli wydajność ma znaczenie, ale nie spodziewam się, że będzie to w ogóle problem.

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

Po prostu łącząc najlepsze odpowiedzi, stworzyłem bardzo proste rozszerzenie:

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

Jest czysty, prosty i, według komentarza @ Jeppe-Stig-Nielsen, szybki.

Istnieją dwa sposoby iteracji Enum:

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

Pierwszy da ci wartości w formie na tablicy ** object** s, a drugi da ci wartości w postaci tablicy **String ** s.

Użyj go w foreachpętli, jak poniżej:

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

Używam ToString (), a następnie dzielę i analizuję tablicę pluć w flagi.

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

Nie uważam, że to jest lepsze, a nawet dobre. Podaję tylko inne rozwiązanie.

Jeśli wartości wyliczeniowe mieszczą się w zakresie od 0 do n - 1, ogólną alternatywą jest:

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

Jeśli wartości wyliczenia są ciągłe i możesz podać pierwszy i ostatni element wyliczenia, to:

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

Ale to nie jest ściśle wyliczenie, tylko zapętlenie. Druga metoda jest jednak znacznie szybsza niż jakiekolwiek inne podejście ...

Jeśli potrzebujesz sprawdzania prędkości i typu w czasie kompilacji i wykonywania, ta metoda pomocnicza jest lepsza niż użycie LINQ do rzutowania każdego elementu:

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

I możesz użyć go jak poniżej:

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

Oczywiście możesz wrócić IEnumerable<T>, ale to nic tu nie kupi.

Oto działający przykład tworzenia wybranych opcji dla 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)))
{
}

(Akceptowana obecnie odpowiedź zawiera obsadę, która moim zdaniem nie jest potrzebna (chociaż mogę się mylić).)

To pytanie pojawia się w rozdziale 10 „ C # krok po kroku 2013 ”

Autor używa podwójnej pętli for do iteracji przez parę urządzeń wyliczających (aby utworzyć pełną talię kart):

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

W tym przypadku Suiti Valueoba są wyliczeniami:

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

i PlayingCardjest obiektem karcianym o zdefiniowanym Suiti Value:

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

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

Wiem, że to trochę bałagan, ale jeśli jesteś fanem jedno-liniowych, oto jeden:

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

Co jeśli wiesz, że typ będzie typu enum, ale nie wiesz, jaki dokładnie jest typ w czasie kompilacji?

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

Metoda getListOfEnumwykorzystuje refleksję do pobrania dowolnego typu wyliczenia i zwraca IEnumerablewszystkie wartości wyliczenia.

Stosowanie:

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

Prosty i ogólny sposób przekonwertowania wyliczenia na coś, w co możesz wchodzić w interakcje:

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

I wtedy:

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

Dodaj metodę public static IEnumerable<T> GetValues<T>()do swojej klasy, na przykład:

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

Zadzwoń i przekaż swój enum. Teraz możesz iterować za pomocą foreach:

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

enumtypy są nazywane „typami wyliczeń” nie dlatego, że są kontenerami, które „wyliczają” wartości (którymi nie są), ale ponieważ są zdefiniowane przez wyliczanie możliwych wartości dla zmiennej tego typu.

(W rzeczywistości jest to nieco bardziej skomplikowane - typy wyliczeniowe są uważane za mające „leżącą u podstaw” liczbę całkowitą, co oznacza, że ​​każda wartość wyliczenia odpowiada wartości całkowitej (jest to zwykle niejawne, ale może być określone ręcznie). C # został zaprojektowany w taki sposób, aby można było wypchać dowolne liczbę całkowitą tego typu do zmiennej wyliczeniowej, nawet jeśli nie jest to wartość nazwana).

Metoda System.Enum.GetNames może być używany do pobierania tablicę łańcuchów, które są nazwy wartości enum, jak sama nazwa wskazuje.

EDYCJA: Powinien zamiast tego zasugerować metodę System.Enum.GetValues . Ups

Próbowałem na wiele sposobów i uzyskałem wynik z tego kodu:

Aby uzyskać listę int z wyliczenia, użyj następujących. To działa!

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

Możesz także powiązać publiczne publiczne elementy wyliczeniowe bezpośrednio, używając odbicia:

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

Jeśli masz:

enum Suit
{
   Spades,
   Hearts,
   Clubs,
   Diamonds
}

To:

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

Wyjdzie:

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

Ogólny sposób 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());

Stosowanie:

        var enums = ToList<Enum>();