How do I enumerate an enum in C#?
71
How can you enumerate a enum in C#?

e.g. the following does not compile:

It gives the compile time error:

'Suit' is a 'type' but is used like a 'variable'

It fails on the Suit keyword, the 2nd one.
improve this question | comment
Gino Medhurst Created at: 2013-11-13 17:07:03 UTC By Gino Medhurst
See also ... stackoverflow.com/questions/972307/… - Dr. Jaycee McGlynn
It might be easiest just to use Enum.GetValues(typeof(Suit)).Cast<Suit>(). That will give you an IEnumerable<Suit>. - Daphnee Spencer
Use the DescriptionAttribute on enum values msdn.microsoft.com/en-us/library/… (example code: codeproject.com/Articles/13821/…) to iterate trough user friendly descriptions of the enum's value. - Miss Berniece Prohaska
16 Answers
0
Why is no one using Cast?

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


There you go IEnumerable<Suit>.
0
> foreach (Suit suit in Enum.GetValues(typeof(Suit))) { }



  I've heard vague rumours that this is
  terifically slow. Anyone know? – Orion
  Edwards Oct 15 '08 at 1:31 7   


I think caching the array would speed it up considerably.  It looks like you're getting a new array (through reflection) every time.  Rather:

Array ar = Enum.GetValues(typeof(Suit));
foreach(Suit temp_suit in ar) Do_Something(temp_suit);


That's at least a little faster, ja?
0
I made some extensions for easy enum usage, maybe someone can use it...

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


The enum itself must be decorated with the FlagsAttribute

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

0
The .NET compact framework does not support Enum.GetValues. Here's a good workaround from Ideas 2.0: Enum.GetValues in Compact Framework:

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

0
I think this is more efficient than other suggestions because GetValues() is not called each time you have a loop. It is also more concise. And you get a compile-time error not a runtime exception if Suit is not an enum.

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


EnumLoop has this completely generic definition:

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

0
You won't get Enum.GetValues() in Silverlight.

Original Blog Post by 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();
    }
}

0
Just to add my solution, which works in compact framework (3.5) and supports type checking at compile time:

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


- If anyone knows how to get rid of the "T valueType = new T()", I'd be happy to see a solution.

A call would look like this:

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

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

0
It looks to me like you really want to print out the names of each enum, rather than the values. In which case Enum.GetNames seems to be the right approach.

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

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


By the way, incrementing the value is not a good way to enumerate the values of an enum. You should do this instead.

I would use Enum.GetValues(typeof(Suit)) instead.

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

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

0
I think you can use

Enum.GetNames(Suit)

0
What the hell I'll throw my two pence in, just by combining the top answers I through together a very simple extension

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.
0
I use ToString() then split and parse the spit array in flags.

[Flags]
public enum ABC {
 a = 1,
 b = 2,
 c = 4
};

public IEnumerable<ABC> Getselected (ABC flags)
{

 var values = value.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
here is a working example of creating select options for a 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()
                            };

0
I do not hold the opinion this is better, or even good, just stating yet another solution.

If enum values range strictly from 0 to n - 1, a generic alternative:

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


If enum values are contiguous and you can provide the first and last element of the enum, then:

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


but that's not strictly enumerating, just looping. The second method is much faster than any other approach though...
0
Three ways:

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


Not sure why was GetEnumValues introduced on type instance, it isn't very readable at all for me.

Having a helper class like Enum<T> is what is most readable and memorable for me:

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


Now you call:

Enum<Suit>.GetValues();
//or
Enum.GetValues(typeof(Suit)); //pretty consistent style


One can also use sort of caching if performance matters, but I dont expect this to be an issue at all

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

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

Your Answer