Simple form of Array class and Enum.GetValues()

Question

I am working with the static method

Enum.GetValues(typeof(SomeEnum));

This method works great when all you need to do is enumerate the values, but for some reason it returns a very simple form of the Array class. I am trying to find an easy way to turn it's return value into a more "normal" collection class like a regular array or List<>.

So far if I want to do that I have to enumerate through the output of Enum.GetValues(typeof(SomeEnum)); and add them one by one to a List<>.

Any ideas how to do this more cleanly?

Answer:

The key is to cast the return result --

SomeEnum[] enums = (SomeEnum[]) Enum.GetValues(typeof(SomeEnum));

If you need a List then jus wrap it in parenthesis and ToList it like so:

List<SomeEnum> list = ((SomeEnum[]) Enum.GetValues(typeof(SomeEnum))).ToList();

Answer 1

How about this:

    List<SomeEnum> list = new List<SomeEnum>();
    foreach (SomeEnum value in Enum.GetValues (typeof (SomeEnum)))
    {
        if (condition)
            list.Add(value);
    }

Answer 2

REVISION (12-Sep-2009 ~2:20 PM EST):

So, I made this suggestion last night on the basis that Enum.GetValues returns an Array, and I thought that Array implements IEnumerable<T>:

I believe you can construct a List<T> passing any IEnumerable<T> as a parameter into the constructor. So you should be able to just do this:

List<SomeEnum> values = new List<SomeEnum>(Enum.GetValues(typeof(SomeEnum)));

However, GordonG quite promptly replied to my answer indicating that it doesn't compile. (Ordinarily I would test my answer, but I was at a computer without any development tools at the time and was also feeling quite [unreasonably] sure of myself.)

After some downvotes and heavy soul-searching I resolved to get to the bottom of this matter (after a good night's sleep). Turns out, according to Microsoft's documentation on the Array class here, that Array does implement IEnumerable<T>, but only at run time (so, not at compile time--hence the failure to compile). This, in hindsight, makes sense: Enum.GetValues is not a generic method, and so it cannot know what sort of generic collection to return beforehand. (At least that's how I understand it.)

Anyway, what this all means is that you can legally cast an Array to an IEnumerable<T> provided that you get your type right. And so, at last I can present my final answer, which is really the same as my original answer but with a simple cast thrown in to make everything legal:

// splitting into two lines just for readability's sake
List<SomeEnum> values;
values = new List<SomeEnum>((IEnumerable<T>) Enum.GetValues(typeof(SomeEnum)));

Of course, in retrospect, GordonG wasn't dead set on getting a List<T>, which means his own answer of casting to SomeEnum[] is really just as good.

Answer 3

I found here you can just do this:

SomeEnum[] enums = (SomeEnum[]) Enum.GetValues(typeof(SomeEnum));

And if you need a List just use .ToList() at the end, like this:

List<SomeEnum> list = ((SomeEnum[]) Enum.GetValues(typeof(SomeEnum))).ToList();

Or if you like this better:

List<SomeEnum> list2 = new List<SomeEnum>((SomeEnum[]) Enum.GetValues(typeof(SomeEnum)));

Answer 4

This should work:

List<MyEnum> enums = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).ToList();

The reason ToList() didn't work in the solution you posted in your question was that you're missing a set of parens around the casted portion. Hope this helps!

Answer 5

If you're using .NET 3.5, you can also use Cast<T> and ToList extension methods.

IEnumerable<SomeEnum> enums = Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>();

You can also get a list if you want to

List<SomeEnum> list =  Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>().ToList();

Answer 6

Inspired by Jon Skeet's unconstrained-melody, I came up with version I like more:

public static class Enum<T>
    where T: struct
{
    static Enum()
    {
        Trace.Assert(typeof(T).IsEnum);
    }

    public static ReadOnlyCollection<T> Values = ((T[])Enum.GetValues(typeof(T))).ToList().AsReadOnly();
}

and usage:

var values = Enum<BindingFlags>.Values;

Good thing is this version works faster for multiple calls because it does not create new array on every time.

Answer 7

I have a brand new library (UnconstrainedMelody) which helps with this. It can return the values in a strongly typed array or in an immutable list:

SomeEnum[] array = Enums<SomeEnum>.GetValuesArray()
IList<SomeEnum> list = Enums<SomeEnum>.GetValues();

It's generic and has a constraint on the type parameter to make sure it's genuinely an enum. This isn't possible in normal C#, but the library does a bit of furtling to make it work. I like the second form more, because we cache the list - the fact that it's immutable means we can return the same reference again and again.

There are various other utility methods to make it easier to work with flags enums etc.

Enjoy.

Answer 8

Updated solution (from 'Konstantin Spirin') for .NET framwork 2.0:

public static class Enum<T> where T : struct
{
    static Enum()
    {
        Trace.Assert(typeof(T).IsEnum);
    }

    public static ReadOnlyCollection<T> Values = new ReadOnlyCollection<T>(((T[])Enum.GetValues(typeof(T))));
}