How to Enumerate an Enum in C#

By the end of this page, you will understand how to loop through every value in a C# enum, why an enum type cannot be used directly in a foreach, and how to use Enum.GetValues(...) correctly in beginner-friendly and real-world code.

In C#, an enum is a type that represents a fixed set of named constants. For example, Suit defines four possible values: Spades, Hearts, Clubs, and Diamonds.

The key idea is this:

• Suit is a type definition
• Suit.Spades is an enum value
• foreach needs a collection of values to iterate over

That is why this does not work:

foreach (Suit suit in Suit)

Here, the second Suit is just the enum type itself, not a list or sequence. foreach cannot loop over a type.

To enumerate all values of an enum, you need to ask .NET for the values defined in that enum. The standard way is:

Enum.GetValues(typeof(Suit))

This returns all defined values for the enum, which you can then loop through.

Think of an enum like a category label printed on a box, and the enum values as the items inside the box.

• Suit = the name on the box
• Spades, Hearts, Clubs, Diamonds = the items inside

You cannot loop over the box label itself. You need to open the box and get the items out first.

Enum.GetValues(typeof(Suit)) is the tool that opens the box and gives you all the values to iterate over.

Basic syntax

In C#, use Enum.GetValues to get all values from an enum.

foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
    DoSomething(suit);
}

Complete example

using System;

public enum Suit
{
    Spades,
    Hearts,
    Clubs,
    Diamonds
}

public class Program
{
    public static void Main()
    {
        foreach (Suit suit in Enum.GetValues(typeof(Suit)))
        {
            Console.WriteLine(suit);
        }
    }
}

Output:

Spades
Hearts
Clubs
Diamonds

Generic version in modern C#

If your C# version supports it, you can use the generic overload:

foreach (Suit suit in Enum.GetValues<Suit>())
{
    Console.WriteLine(suit);
}

This version is cleaner because you do not need typeof(Suit) or casting.

Consider this code:

using System;

public enum Suit
{
    Spades,
    Hearts,
    Clubs,
    Diamonds
}

public class Program
{
    public static void Main()
    {
        foreach (Suit suit in Enum.GetValues(typeof(Suit)))
        {
            Console.WriteLine($"Current suit: {suit}");
        }
    }
}

Here is what happens step by step:

1. The enum Suit is defined with four members.
2. Enum.GetValues(typeof(Suit)) asks .NET for all values declared in the Suit enum.
3. .NET returns a collection containing:
   • Suit.Spades
   • Suit.Hearts
   • Suit.Clubs
   • Suit.Diamonds
4. The foreach loop starts with the first value.
5. The variable suit becomes .

Building a dropdown or menu

Enums are often used for a fixed list of options. For example:

• payment status
• shipping method
• user role
• order state

You can enumerate the enum to display all choices.

public enum OrderStatus
{
    Pending,
    Paid,
    Shipped,
    Cancelled
}

foreach (OrderStatus status in Enum.GetValues(typeof(OrderStatus)))
{
    Console.WriteLine(status);
}

Validating input

You may want to compare input against all valid enum values.

Running logic for every case

In games or simulations, you might apply rules for every possible state or category.

Generating reports

If an enum represents categories, you can loop through all categories and summarize data for each one.

Seeding configuration or defaults

A real application may create default records for every enum member, such as permissions or settings.

In real projects, developers usually do more than just print enum values. They combine enum enumeration with common patterns.

1. Creating UI options

var suitOptions = Enum.GetValues(typeof(Suit))
    .Cast<Suit>()
    .Select(s => s.ToString())
    .ToList();

This is useful when building select lists or API response options.

2. Validation

public bool IsValidSuit(Suit suit)
{
    return Enum.IsDefined(typeof(Suit), suit);
}

This helps when values may come from external input.

3. Guard clauses

public void ProcessSuit(Suit suit)
{
    if (!Enum.IsDefined(typeof(Suit), suit))
    {
        throw new ArgumentException("Invalid suit value.");
    }

    Console.WriteLine($"Processing {suit}");
}

4. Filtering enum values

Sometimes not every enum value should be shown.

Mistake 1: Trying to loop over the enum type directly

Broken code:

foreach (Suit suit in Suit)
{
    Console.WriteLine(suit);
}

Why it fails:

• Suit is a type, not a collection.
• foreach requires something enumerable.

Fix:

foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
    Console.WriteLine(suit);
}

Mistake 2: Forgetting to cast when needed

Enum.GetValues(typeof(Suit)) returns an array-like collection of enum values, but older syntax may require casting when using LINQ.

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

Mistake 3: Confusing names with values

Enum.GetNames returns strings, not enum values.

foreach (string name in Enum.GetNames(typeof(Suit)))
{
    Console.WriteLine(name);
}

Enumerate all enum values

foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
    Console.WriteLine(suit);
}

Modern generic syntax

foreach (Suit suit in Enum.GetValues<Suit>())
{
    Console.WriteLine(suit);
}

Get enum names as strings

foreach (string name in Enum.GetNames(typeof(Suit)))
{
    Console.WriteLine(name);
}

Get underlying numeric value

int value = (int)Suit.Spades;

Validate enum value

bool isValid = Enum.IsDefined(typeof(Suit), suit);

Key rule

• An enum type like Suit is not a collection.
• Use Enum.GetValues(...) when you want to loop through all members.

Common pattern

How do you loop through enum values in C#?

Use Enum.GetValues(typeof(YourEnum)) or Enum.GetValues<YourEnum>() and iterate with foreach.

Why can't I use the enum type directly in foreach?

Because the enum type is only a type definition, not a collection of values. foreach needs something enumerable.

What is the difference between Enum.GetValues and Enum.GetNames?

Enum.GetValues returns actual enum values. Enum.GetNames returns their names as strings.

Does Enum.GetValues return values in declaration order?

It returns the enum values defined for that type. In common cases this matches the declared members, but the important point is that it returns the defined enum values rather than the type itself.

Can an enum contain values not explicitly declared?

Yes. Because enums are numeric underneath, you can cast a number to an enum even if it is not declared. Use Enum.IsDefined to validate.

Is there a generic version of Enum.GetValues?

Yes. In modern C#, you can use , which is cleaner and type-safe.

• enum parsing — useful when converting strings or numbers into enum values.
• Enum.IsDefined — helps validate whether a value is actually declared in the enum.
• switch expressions — commonly used to perform different actions for enum values.
• foreach loop — the loop construct used to iterate through enum values.
• type casting — important when converting enums to and from integers.
• LINQ Cast<T>() — often used when working with values returned by Enum.GetValues.
• flags enums — a related enum style used when values can be combined.
• ToString() — commonly used to turn enum values into readable text.