Switch enum. In C# switch can act upon enum values. An enum switch sometimes results in clearer code. The resulting instructions are sometimes faster as well.

A common pattern. The C# switch-enum code pattern is often effective. It is used in many real-world programs (not just website examples).

Example. Enums help us deal with magic constants. For the switch statement here, look at the IsImportant method—it uses 5 explicit cases and a default case.

using System;

enum Priority
{
    Zero,
    Low,
    Medium,
    Important,
    Critical
};

class Program
{
    static void Main()
    {
        // New local variable of the Priority enum type.
        Priority priority = Priority.Zero;

        // Set priority to critical on Monday.
        if (DateTime.Today.DayOfWeek == DayOfWeek.Monday)
        {
            priority = Priority.Critical;
        }

        // Write this if the priority is important.
        if (IsImportant(priority))
        {
            Console.WriteLine("The problem is important.");
        }

        // See if Low priority is important.
        priority = Priority.Low;
        Console.WriteLine(IsImportant(priority));

        // See if Important priority is.
        priority = Priority.Important;
        Console.WriteLine(IsImportant(priority));
    }

    static bool IsImportant(Priority priority)
    {
        // Switch on the Priority enum.
        switch (priority)
        {
            case Priority.Low:
            case Priority.Medium:
            case Priority.Zero:
            default:
                return false;
            case Priority.Important:
            case Priority.Critical:
                return true;
        }
    }
}
The problem is important.
False
True

Internals. How is the enum switch compiled? The C# code is compiled into a special .NET instruction called a jump table. The jump table uses the IL instruction switch.

L_0004: switch (L_001f, L_001f, L_001f, L_0023, L_0023)

A recommendation. When you have a set of constants, I recommend you use switch—it can have better performance. And the code is clearer to read.

A summary. We saw examples of how you can switch on enums. Switch can improve performance when it is implemented by a jump table in the MSIL. This is determined by the compiler.