Jak wyliczyć enum w C#?

Wygląda na to, że naprawdę chcesz wydrukować nazwy każdego enum, a nie wartości. W takim przypadku Enum.GetNames() wydaje się być właściwym podejściem.

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

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

Przy okazji, zwiększanie wartości nie jest dobrym sposobem na wyliczenie wartości z enum. Powinieneś to zrobić.

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ś z nich skorzysta...

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 flagami

[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 z Ideas 2.0: Enum. GetValues in 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;
}

Podobnie jak w przypadku każdego kodu, który zawiera odbicie , należy podjąć kroki, aby upewnić się, że działa tylko raz, a wyniki są buforowane.

Myślę, że jest to bardziej efektywne niż inne sugestie, ponieważ {[2] } nie jest wywoływana za każdym razem, gdy masz pętlę. Jest również bardziej zwięzły. I dostajesz błąd w czasie kompilacji, a nie wyjątek runtime, jeśli Suit nie 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]);
        }
    }
}

Dlaczego nikt nie używa Cast<T>?

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

Nie dostaniesz się do Silverlight.

Oryginalny Post na blogu 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();
    }
}

Aby dodać moje rozwiązanie, które działa w kompaktowym frameworku (3.5) i obsługuje sprawdzanie typu 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ę pozbyć T valueType = new T(), chętnie zobaczę rozwiązanie.

Wywołanie 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 pogłoski, że to terificznie powolny. Ktoś wie? - Orion Edwards Oct 15 ' 08 at 1: 31 7

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

Trzy sposoby:

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

nie jestem pewien, dlaczego GetEnumValues została wprowadzona na instancję type, nie jest ona dla mnie zbyt czytelna.

Posiadanie klasy pomocniczej takiej jak {[5] } 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ć buforowania, jeśli wydajność ma znaczenie, ale nie oczekuję, że to będzie 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)));
    }
}

Co do diabła wrzucę moje dwa pensy, po prostu łącząc najlepsze odpowiedzi, które przejrzałem razem 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 Enum value)
    {
        return (T[])Enum.GetValues(typeof (T));
    }
}

Clean simple and by @ Jeppe-Stig - Nielsen s comment fast.

Używam ToString (), a następnie dzielę i analizuję tablicę spit w flags.

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

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 postaci tablicy object, a drugi da ci wartości w postaci tablicy String.

Użyj go w pętli foreach Jak poniżej:

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

Nie uważam, że jest to lepsze, a nawet dobre, po prostu podając kolejne rozwiązanie.

Jeśli wartości enum wahają się ściśle od 0 do n-1, alternatywa ogólna:

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 enum są sąsiadujące ze sobą i możesz podać pierwszy i ostatni element enum, to:

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

Jeśli potrzebujesz sprawdzania szybkości i typu w czasie budowania i uruchamiania, ta metoda pomocnicza jest lepsza niż używanie LINQ do rzucania 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 go używać jak poniżej:

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

Oto roboczy przykład tworzenia opcji select 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)))
{
}

(obecna akceptowana odpowiedź ma obsadę, której nie sądzę jest potrzebna (choć mogę się mylić).)

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

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 Suit i Value są wyliczeniami:

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

I PlayingCard jest obiektem karty o zdefiniowanym Suit i 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 jest trochę bałagan, ale jeśli jesteś fanem jednowierszowców, tutaj jest jeden:

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

Prosty i ogólny sposób konwersji enum na coś, co można współdziałać:

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

A następnie:

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

Co jeśli wiesz, że typ będzie enum, ale nie wiesz, jaki dokładnie typ jest 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 getListOfEnum wykorzystuje odbicie do pobrania dowolnego typu enum i zwraca IEnumerable wszystkich wartości enum.

Użycie:

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

Dodaj metodę public static IEnumerable<T> GetValues<T>() do swojej klasy, jak

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

Wywołaj i podaj swój enum, teraz możesz go iterować używając foreach

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

Możesz również powiązać z publicznymi statycznymi członkami enum bezpośrednio za pomocą reflection:

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

enum typy są nazywane "typami wyliczeń" nie dlatego, że są kontenerami, które "wyliczają" wartości (których nie są), ale dlatego, że są zdefiniowane przez wyliczenie możliwych wartości dla zmiennej tego typu.

(w rzeczywistości jest to nieco bardziej skomplikowane - typy enum są uważane za "bazowe" typy całkowite, co oznacza, że każda wartość enum odpowiada wartości całkowitej (zwykle jest to niejawne, ale może być ręcznie określone). C # został zaprojektowany w sposób, dzięki któremu można umieścić dowolną liczbę całkowitą tego typu do zmiennej enum, nawet jeśli nie jest to wartość "named".)

System .Enum.Metoda GetNames może być użyta do pobrania tablicy łańcuchów, które są nazwami wartości enum, jak sama nazwa wskazuje.

EDIT: powinien był zasugerować system .Enum.Zamiast tego metoda GetValues. UPS.