DamienG

Using LINQ to foreach over an enum in C#

  • đź“…
  • đź“ť 188
  • đź•™ 1
  • 📦 .NET
  • đź’¬ 8

I later expanded this out into a full Enum<T> strongly typed helper.

I can’t be the only person in the world who wants to foreach over the values of an enum otherwise Enum.GetValues(Type enumType) wouldn’t exist in the framework. Alas it didn’t get any generics love in .NET 2.0 and unhelpfully returns an array.

Thanks to the power of LINQ you can do this:

foreach(var customerType in Enum.GetValues(typeof(CustomerTypes)).Cast<CustomerTypes>()))

That is okay, but this is more concise:

foreach(CustomerTypes customerType in Enums.Get<CustomerTypes>())

The tiny class to achieve that is, of course:

using System.Collections.Generic;
using System.Linq;

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

Great.

[)amien

8 responses to Using LINQ to foreach over an enum in C#

  1. Avatar for

    Information is only used to show your comment. See my Privacy Policy.

  2. Avatar for Jesse Pakin
    Jesse Pakin

    Thanks for the post. I was able to use it along with another posting regarding custom attributes to list out friendly names for enums in a dropdown, in a view in an MVC project (with a nice bit of LINQ).

    <%: Html.DropDownList("CardRecord.Type",((IList<CreditCardType
  >)Enum.GetValues(typeof(CreditCardType))).Select(s => new SelectListItem{Text
  = s.GetStringValue(), Value = s.ToString()}))%></CreditCardType
>
  3. Avatar for Florent
    Florent

    Hi guys :)

    I think that Cast method is not mandatory… In fact, you can directly cast that Enum.GetValues return into IEnumerable. Because it’s a simple array :)

    So you can do like this:

    IEnumerable<T> myEnumerableOfEnum = (IEnumerable<T>)Enum.GetValues(typeof(T));

    But you can do this too:

    IList<T> myListOfEnum = (IList<T>)Enum.GetValues(typeof(T));
T[] myArrayOfEnum = (T[])Enum.GetValues(typeof(T));

    I hope this will useful :)

  4. Avatar for Richard
    Richard
    hope you don't mind me reformatting it

    No problem.

    This is the second time I would have liked to write an extension method that extends the target’s static methods (rather than instance).

  5. Avatar for Damien Guard
    Damien Guard

    That’s nice! (hope you don’t mind me reformatting it). I did consider going with an extension method but my worry was having .Values appear for all classes.

  6. Avatar for Richard
    Richard

    You can make use of an extension method to make this slightly nicer… but you call the extension against an instance of the enum (naming for the extension needs to be better):

    using System;
using System.Collections.Generic;
using System.Linq;

static class Enums {
    public static IEnumerable<T> Values<T>(this T en) where T : struct {
        if (!typeof(T).IsEnum)
            throw new InvalidOperationException();
        foreach (var x inEnum.GetValues(typeof(T)).Cast<T>())
            yield return x;
    }
}

enum Test { One, Two, Three }

class Program {
    static void Main(string[] args) {
        IEnumerable<Test> t = Test.One.Values();
        foreach (var x in t)
            Console.WriteLine(x);
    }
}
  7. Avatar for Steve
    Steve

    Yuck. Equivalent Java code:

    for (CustomerTypes customerType : CustomerTypes.values())

    One of the rare occasions Java is more concise than C#, obviously ;)

  8. Avatar for Damien Guard
    Damien Guard

    Good question!

    LINQ uses some specific compiler magic for the select/in/where/order keywords and also has a bunch of classes in the System.Linq namespace.

    To achieve the functionality requires these classes use Extension methods quite extensively. It also takes advantage of Lambda expressions, anonymous types and is demonstrated often using type inference, all C# 3.0 features!

  9. Avatar for Guy
    Guy

    Great post and valuable information — bookmarked and will be used in the future. :)

    Question: Is it actually the power of LINQ that you’re using? i.e. Are extension methods part of LINQ or are they part of C# 3.0?