How to loop through an enum in C#

// Enum.GetValues<TEnum>() (.NET 5+) returns every member as a Suit[]
foreach (Suit suit in Enum.GetValues<Suit>())
{
    Console.WriteLine($"{suit} = {(int)suit}");
}

Suit[] suits = Enum.GetValues<Suit>();
Console.WriteLine($"{suits.Length} suits: {string.Join(", ", suits)}");

// It is an ordinary array, so indexing and LINQ work on it
Console.WriteLine(suits[^1]);
Console.WriteLine(suits.Max());
Console.WriteLine(string.Join(" ", suits.Where(s => s is Suit.Diamonds or Suit.Hearts)));

// Two enums, two loops: every card in a deck
List<string> deck = [];
foreach (Suit suit in Enum.GetValues<Suit>())
{
    foreach (Rank rank in Enum.GetValues<Rank>())
    {
        deck.Add($"{rank} of {suit}");
    }
}
Console.WriteLine($"{deck.Count} cards, first {deck[0]}, last {deck[^1]}");

// Each call builds a new array, so keep it in a variable inside hot loops
Console.WriteLine(ReferenceEquals(Enum.GetValues<Suit>(), Enum.GetValues<Suit>()));

enum Suit { Clubs, Diamonds, Hearts, Spades }

enum Rank { Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace }

// Just the names, as a string[] (.NET 5+)
string[] names = Enum.GetNames<Suit>();
Console.WriteLine(string.Join(", ", names));

// Older code (.NET Framework, .NET Core 3.1) passes a Type and gets an untyped Array
Array values = Enum.GetValues(typeof(Suit));
Console.WriteLine(values.GetType());

// foreach casts each element to the loop variable's type
foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
    Console.Write($"{suit} ");
}
Console.WriteLine();

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

// Array is not IEnumerable<Suit>, so LINQ needs Cast<Suit>() first
IEnumerable<Suit> red = Enum.GetValues(typeof(Suit))
    .Cast<Suit>()
    .Where(s => s is Suit.Diamonds or Suit.Hearts);
Console.WriteLine(string.Join(", ", red));

// The non-generic form doesn't check the loop type: this compiles, runs and
// turns the seven DayOfWeek values into Suit values
foreach (Suit suit in Enum.GetValues(typeof(DayOfWeek)))
{
    Console.Write($"{suit} ");
}
Console.WriteLine();

enum Suit { Clubs, Diamonds, Hearts, Spades }

// Values into a List<Suit>: ToList(), or a collection expression (C# 12)
List<Suit> suits = Enum.GetValues<Suit>().ToList();
List<Suit> copy = [.. Enum.GetValues<Suit>()];
suits.Remove(Suit.Clubs);
Console.WriteLine($"{string.Join(", ", suits)} | {copy.Count}");

// Names into a List<string>
List<string> names = [.. Enum.GetNames<Suit>()];
Console.WriteLine(string.Join(", ", names));

// Value/name pairs, e.g. for a dropdown or an API response
List<Option> options = Enum.GetValues<Suit>()
    .Select(s => new Option((int)s, s.ToString()))
    .ToList();
foreach (Option option in options)
{
    Console.WriteLine(option);
}

// Look up the number by name
Dictionary<string, int> byName = Enum.GetValues<Suit>().ToDictionary(s => s.ToString(), s => (int)s);
Console.WriteLine(byName["Hearts"]);

// All members except some
Suit[] notClubs = [.. Enum.GetValues<Suit>().Except([Suit.Clubs, Suit.Spades])];
Console.WriteLine(string.Join(", ", notClubs));

// A HashSet for fast membership checks
HashSet<Suit> set = [.. Enum.GetValues<Suit>()];
Console.WriteLine(set.Contains(Suit.Spades));

enum Suit { Clubs, Diamonds, Hearts, Spades }

record Option(int Value, string Name);

// GetValues sorts by the underlying value, not by declaration order
foreach (Status status in Enum.GetValues<Status>())
{
    Console.WriteLine($"{(int)status,3} {status}");
}

// Two names for one value: GetNames lists both, GetValues repeats the value
Console.WriteLine(string.Join(", ", Enum.GetNames<Level>()));
Console.WriteLine(string.Join(", ", Enum.GetValues<Level>()));
Console.WriteLine(string.Join(", ", Enum.GetValues<Level>().Distinct()));
Console.WriteLine($"{Enum.GetNames<Level>().Length} names, {Enum.GetValues<Level>().Distinct().Count()} distinct values");

// A [Flags] enum also returns None and any combined members
Console.WriteLine(string.Join(", ", Enum.GetValues<Access>()));

// Only the single-bit flags (int.IsPow2 is .NET 7+)
Access[] flags = [.. Enum.GetValues<Access>().Where(a => int.IsPow2((int)a))];
Console.WriteLine(string.Join(", ", flags));

// The flags that are set in one value
Access granted = Access.Read | Access.Delete;
Console.WriteLine(string.Join(", ", flags.Where(f => granted.HasFlag(f))));

enum Status { Active = 1, Archived = 3, Draft = 0, Deleted = -1 }

enum Level { Low = 1, Medium = 2, High = 3, Normal = 2 }

[Flags]
enum Access { None = 0, Read = 1, Write = 2, ReadWrite = Read | Write, Delete = 4 }

// One helper for any enum: the struct, Enum constraint (C# 7.3+) allows GetValues<T>()
static string ListAll<T>() where T : struct, Enum
{
    T[] values = Enum.GetValues<T>();
    return $"{typeof(T).Name} ({values.Length}): {string.Join(", ", values)}";
}

Console.WriteLine(ListAll<Suit>());
Console.WriteLine(ListAll<DayOfWeek>());

// Only a Type at run time (reflection, plugins): use the non-generic overloads
Type type = typeof(FileAccess);
Console.WriteLine(type.IsEnum);
foreach (object value in Enum.GetValues(type))
{
    Console.Write($"{value}={Convert.ToInt32(value)} ");
}
Console.WriteLine();

// The raw numbers, typed as the underlying type (.NET 7+)
Array raw = Enum.GetValuesAsUnderlyingType<Color>();
Console.WriteLine($"{raw.GetType()}: {string.Join(", ", raw.Cast<byte>())}");
Console.WriteLine(Enum.GetUnderlyingType(typeof(Color)));

// Next member, wrapping around at the end
static T Next<T>(T value) where T : struct, Enum
{
    T[] values = Enum.GetValues<T>();
    int index = Array.IndexOf(values, value);
    return values[(index + 1) % values.Length];
}

Console.WriteLine($"{Next(Suit.Hearts)} {Next(Suit.Spades)} {Next(DayOfWeek.Saturday)}");

enum Suit { Clubs, Diamonds, Hearts, Spades }

enum Color : byte { Red = 10, Green = 20, Blue = 30 }

using System.ComponentModel;
using System.Reflection;

// Display text for each member, read from a [Description] attribute
foreach (OrderStatus status in Enum.GetValues<OrderStatus>())
{
    Console.WriteLine($"{status,-10} {status.GetDescription()}");
}

// A list of (value, text) pairs for a dropdown
var items = Enum.GetValues<OrderStatus>()
    .Select(s => (Value: (int)s, Text: s.GetDescription()))
    .ToList();
Console.WriteLine(items[1]);

// Or skip reflection: a switch expression maps each member to its text
static string Label(OrderStatus status) => status switch
{
    OrderStatus.Pending => "Waiting",
    OrderStatus.Shipped => "On its way",
    OrderStatus.Delivered => "Done",
    OrderStatus.Cancelled => "Cancelled",
    _ => status.ToString(),
};

Console.WriteLine(string.Join(" / ", Enum.GetValues<OrderStatus>().Select(Label)));

enum OrderStatus
{
    [Description("Waiting for payment")] Pending,
    [Description("Shipped, on its way")] Shipped,
    [Description("Delivered to the customer")] Delivered,
    Cancelled,
}

static class EnumExtensions
{
    // Falls back to the member name when there is no attribute
    public static string GetDescription<T>(this T value) where T : struct, Enum
    {
        FieldInfo? field = typeof(T).GetField(value.ToString());
        return field?.GetCustomAttribute<DescriptionAttribute>()?.Description ?? value.ToString();
    }
}