The Evolution of the switch Statement in C#

object message = 150;

switch (message)
{
    case int number when number > 100:
        // Execute logic...
        break;

    case int number:
        // Execute logic...
        break;

    default:
        // Execute logic...
        break;
}

Now switch isn't simply checking whether the value is an int.

It's checking:

Is it an int?
    Is it greater than 100?
       yes -> Large number

The when clause adds another condition to the pattern. Modern C# still supports this approach.

5. C# 8: the switch expression

Then came another major change: the switch expression.

This is probably the change that made modern switch look completely different from the old version.

Previously, if we wanted to convert an order status into a message, we might write:

string GetMessage(Role role)
{
    switch (role)
    {
        case Role.Viewer:
            return // Execute logic...

        case Role.Admin:
            return // Execute logic...

        case Role.Editor:
            return // Execute logic...

        default:
            return // Execute logic...
    }
}

C# 8 introduced a much more concise way of expressing the same idea:

string GetMessage(Role role)
{
    return role switch
    {
        Role.Editor=> "Is Editor",
        Role.Admin => "Is Admin",
        Role.Viewer => "Is Viewer",
        _ => "Is User"
    };
}

This is called a switch expression because it produces a value.

6. C# 9: relational and logical patterns

We are not done yet, the evolution didn't stop there.

C# 9 introduced relational patterns such as:

< 18
>= 18
> 100
<= 500

and logical patterns such as:

and
or
not

7. Property patterns

Now things get more interesting.

Suppose we have:

public class Customer
{
    public string Country { get; set; }
    public int Age { get; set; }
}

We can use a switch to inspect the object's properties.

string GetCustomerCategory(Customer customer) =>
    customer switch
    {
        { Country: "Tunisia", Age: >= 18 } => "Adult customer from Tunisia",
        { Country: "France", Age: >= 18 } => "Adult customer from France",
        { Age: < 18 } => "Minor",
        _ => "Other"
    };

Notice that we're no longer switching on a single value.

We're matching the shape and properties of an object.

This is called a property pattern.

8. C# 11: list patterns

Another interesting addition was list patterns.

You can now match the structure of an array or collection.

For example:

string Describe(int[] values) =>
    values switch
    {
        [] => "Empty",
        [1, 2, 3] => "Exactly 1, 2, 3",
        [1, ..] => "Starts with 1",
        [.., 5] => "Ends with 5",
        _ => "Something else"
    };

9. switch statement vs switch expression

This is something I think is worth making clear because the terminology can be confusing.

They're related, but they're not the same thing.

A switch statement:

switch (status)
{
    case OrderStatus.Paid:
        SendEmail();
        UpdateDatabase();
        break;

    case OrderStatus.Cancelled:
        Refund();
        break;
}

is useful when each branch needs to execute one or more operations.

A switch expression:

var message = status switch
{
    OrderStatus.Paid => "Payment received",
    OrderStatus.Cancelled => "Order cancelled",
    _ => "Unknown"
};

is useful when the main purpose is to calculate a value.