C# switch Statement: case, break, default and Multiple Cases

A switch statement compares one value against a list of constant case labels and runs the section that matches. In C#, every section must end with break (or another statement that leaves it), so one case can never silently run into the next.

using System;

class Program
{
    static void Describe(int statusCode)
    {
        switch (statusCode)
        {
            case 200:
                Console.WriteLine($"{statusCode}: OK");
                break;
            case 301:
            case 302:
                Console.WriteLine($"{statusCode}: redirect");
                break;
            case 404:
                Console.WriteLine($"{statusCode}: not found");
                break;
            default:
                Console.WriteLine($"{statusCode}: unhandled status");
                break;
        }
    }

    static void Main()
    {
        int[] codes = { 200, 302, 404, 500 };
        foreach (int code in codes)
        {
            Describe(code);
        }
    }
}

Output:

200: OK
302: redirect
404: not found
500: unhandled status

The value in parentheses is evaluated once and compared against each label. default runs when nothing matches; it is optional, and it may appear anywhere in the list, although it usually goes last. If there is no match and no default, the whole switch does nothing.

Every Section Needs a break

In C, C++, Java and JavaScript, forgetting break makes execution slide into the next case. C# turns that mistake into a compile error:

switch (level)
{
    case 1:
        Console.WriteLine("read");
        // error CS0163: Control cannot fall through from one case label ('case 1:') to another
    case 2:
        Console.WriteLine("write");
        break;
}

The rule is that the end of a section's statement list must not be reachable. break is the usual way to satisfy it, but anything that leaves the section works:

• return leaves the whole method, which is often the neatest form inside a small helper.
• throw raises an exception for a value that should never occur.
• continue jumps to the next iteration when the switch sits inside a loop.
• goto case and goto default jump to another section on purpose.

The last section is not exempt. A default: at the bottom without break fails with CS8070, Control cannot fall out of switch from final case label ('default:').

Several Values in One Case

Labels with no statements between them share the section below them. This is the one kind of fall-through C# allows, because an empty label cannot hide any code:

using System;

class Program
{
    static string Kind(char c)
    {
        switch (char.ToLowerInvariant(c))
        {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                return "vowel";
            case ' ':
            case '\t':
                return "space";
            default:
                return char.IsDigit(c) ? "digit" : "consonant or symbol";
        }
    }

    static void Main()
    {
        foreach (char c in "Ok 7")
        {
            Console.WriteLine($"'{c}' is a {Kind(c)}");
        }
    }
}

Output:

'O' is a vowel
'k' is a consonant or symbol
' ' is a space
'7' is a digit

Each section here ends with return, so no break is needed (a break after a return would be unreachable code). Two labels with the same value are an error, CS0152 The switch statement contains multiple cases with the label value '1', and every label must be a compile-time constant: a variable in a case fails with "a constant value is expected".

Switch on a String

Strings are the most common switch value after integers. The comparison is ordinal and case-sensitive, so normalize the input before switching:

using System;

class Program
{
    static void Main()
    {
        string[] commands = { "start", "STOP", "  Status ", "restart", null };

        foreach (string raw in commands)
        {
            string command = raw == null ? null : raw.Trim().ToLowerInvariant();

            switch (command)
            {
                case "start":
                    Console.WriteLine("Starting the server");
                    break;
                case "stop":
                    Console.WriteLine("Stopping the server");
                    break;
                case "status":
                    Console.WriteLine("Server is running");
                    break;
                default:
                    Console.WriteLine($"Unknown command: {command ?? "(none)"}");
                    break;
            }
        }
    }
}

Output:

Starting the server
Stopping the server
Server is running
Unknown command: restart
Unknown command: (none)

Without ToLowerInvariant, "STOP" would reach default. A null value is legal to switch on: it matches no string constant and falls to default, so the switch itself never throws.

Switch on an Enum

Enums are what switch was made for: a closed set of named values.

using System;

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

class Program
{
    static string Next(OrderStatus status)
    {
        switch (status)
        {
            case OrderStatus.Pending:
                return "wait for payment";
            case OrderStatus.Paid:
                return "pack and ship";
            case OrderStatus.Shipped:
                return "track the parcel";
            case OrderStatus.Delivered:
            case OrderStatus.Cancelled:
                return "nothing, order is closed";
            default:
                throw new ArgumentOutOfRangeException(nameof(status));
        }
    }

    static void Main()
    {
        foreach (OrderStatus s in Enum.GetValues(typeof(OrderStatus)))
        {
            Console.WriteLine($"{s}: {Next(s)}");
        }
        try
        {
            Next((OrderStatus)42);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine($"{e.GetType().Name} for value 42");
        }
    }
}

Output:

Pending: wait for payment
Paid: pack and ship
Shipped: track the parcel
Delivered: nothing, order is closed
Cancelled: nothing, order is closed
ArgumentOutOfRangeException for value 42

The compiler does not check that a switch statement covers every enum member, and an enum variable can hold any integer of its underlying type ((OrderStatus)42 is legal). The default that throws turns a forgotten case into an immediate, obvious failure instead of a silent no-op.

goto case and goto default

When one case really should continue into another, C# makes you write the jump:

using System;

class Program
{
    static void Grant(string role)
    {
        Console.WriteLine($"{role}:");
        switch (role)
        {
            case "admin":
                Console.WriteLine("  manage users");
                goto case "editor";
            case "editor":
                Console.WriteLine("  edit posts");
                goto default;
            default:
                Console.WriteLine("  read posts");
                break;
        }
    }

    static void Main()
    {
        Grant("admin");
        Grant("editor");
        Grant("guest");
    }
}

Output:

admin:
  manage users
  edit posts
  read posts
editor:
  edit posts
  read posts
guest:
  read posts

goto case takes a constant that must match one of the labels in the same switch. It is rare in real code: shared behavior is usually clearer as a method that several cases call. It is still the answer to "how do I fall through in C#".

Variables Inside Cases

The whole switch block is one scope, so two cases cannot declare a variable with the same name:

switch (shape)
{
    case "square":
        int area = side * side;
        break;
    case "rectangle":
        int area = width * height;   // error CS0128: A local variable or function named 'area' is already defined in this scope
        break;
}

Wrap each section's body in braces to give it its own scope: case "square": { int area = side * side; ... break; }.

break Inside a Loop

break in a case leaves the switch, not the loop around it. continue does the opposite: a switch is not a loop, so continue goes to the loop's next iteration.

using System;

class Program
{
    static void Main()
    {
        string[] lines = { "10", "# comment", "25", "end", "99" };
        int total = 0;

        foreach (string line in lines)
        {
            switch (line)
            {
                case "end":
                    Console.WriteLine("end marker found");
                    break;              // leaves the switch only
                default:
                    if (line.StartsWith("#"))
                        continue;       // skips to the next line
                    total += int.Parse(line);
                    break;
            }
        }

        Console.WriteLine($"Total: {total}");
    }
}

Output:

end marker found
Total: 134

The loop kept going after "end" and added 99. To stop the loop from inside a switch, set a flag and test it after the switch, or move the loop into a method and return. The break and continue page compares the options.

Pattern Case Labels and when

Since C# 7.0, a case label can be a pattern instead of a constant: it can test the type of the value and add a when condition. This form is common in modern C# code:

static string Describe(object value)
{
    switch (value)
    {
        case null:
            return "nothing";
        case int n when n < 0:
            return $"negative int {n}";
        case int n:
            return $"int {n}";
        case string s when s.Length == 0:
            return "empty string";
        case string s:
            return $"string \"{s}\"";
        default:
            return $"other: {value.GetType().Name}";
    }
}

With patterns, order matters: the first matching case wins, and the compiler reports an error when a case can never be reached because an earlier one already covers it (putting case int n: above case int n when n < 0: fails). The when clause also works on constant cases: case 0 when isAdmin:. C# 9 added relational and logical patterns, so a case can read case >= 90: or case 'a' or 'e' or 'i':.

In C# 7 without patterns, the same type dispatch is an if chain with the is type pattern:

using System;

class Program
{
    static string Describe(object value)
    {
        if (value == null) return "nothing";
        if (value is int n) return n < 0 ? $"negative int {n}" : $"int {n}";
        if (value is string s) return s.Length == 0 ? "empty string" : $"string \"{s}\"";
        return $"other: {value.GetType().Name}";
    }

    static void Main()
    {
        object[] values = { -3, 12, "", "hi", 2.5m, null };
        foreach (object v in values)
        {
            Console.WriteLine(Describe(v));
        }
    }
}

Output:

negative int -3
int 12
empty string
string "hi"
other: Decimal
nothing

When every branch of a switch only computes a value, the switch expression is shorter still: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. The switch expression page covers its syntax, patterns and exhaustiveness rules.

What You Can Switch On