c# - iterating on enum type

itemprop="text">

I
don't know if it is possible to do what I want to do, but I think why
not.

I have example
enum:

public enum Animals
            {
 Cat,
 Dog,

            ...
}

What
I want to do is to iterate on this enum. I want it work like
that:

foreach( var type in Animals
            ) {
 Console.WriteLine( type.toString()
            );
}

and the
output will be:

            Cat


            Dog

Is it possible? I
don't want to put every item to an array, and then iterate, I want to iterate directly
on this enum.

itemprop="text">

class="normal">Answer

EDIT: Note
that throughout this answer I've renamed Animals to
Animal. According to .NET conventions, only flags-based enums
should have a plural name.

You can use href="http://msdn.microsoft.com/en-us/library/system.enum.getvalues.aspx"
rel="noreferrer">Enum.GetValues():

foreach
            (var type in (Animal[]) Enum.GetValues(typeof(Animal)) {


            Console.WriteLine(type.toString());
}

As
noted in Dan's comment, if you use explicit typing in your
foreach loop, you don't need to
cast:

foreach (Animal type in
            Enum.GetValues(typeof(Animal)) {

            Console.WriteLine(type.toString());
}

But
now you won't spot errors as early as you could. For
example:

foreach (Animal type in
            Enum.GetValues(typeof(SomeEmptyEnum)) {

            Console.WriteLine(type.toString());
}

Where
SomeEmptyEnum is (obviously) an empty enum type. Here
GetValues will return an empty array of type
SomeEmptyEnum[]. The code above will only check that
each member of the returned array is of the right type, so you
won't spot the problem. Obviously this is unlikely to happen in real life, but it
demonstrates the sort of code smell which leads me to cast the result instead -
basically I far prefer dealing with strongly-typed
collections.

/>

Alternatively, for a somewhat more typesafe
approach, you can use my rel="noreferrer">Unconstrained Melody
library:

foreach (var type in
            Enums.GetValues()) {

            Console.WriteLine(type.ToString());
}

Here
my Enums.GetValues() returns an
IList, which
means:

• There's
  no need to cast


• It actually returns an immutable list, so
  it doesn't need to create a new collection each time, unlike the standard
  Enum.GetValues()

It's
also got a generic constraint forcing T to be an enum type, so
you can't accidentally call it with a non-enum type, unlike
Enum.GetValues()...