C# switch - Which variation do you prefer?
Tags: csharp, discuss
Published: 2020-03-12 10:28:03

---
title: C# switch - Which variation do you prefer?
published: true
description: This article would like to discuss diffrent variations of the C# switch statement / expression.
tags: csharp, discuss
---

Let's say I have the following `Enum`:
```csharp
public enum Cases
{
    One,
    Two,
    Three,
    Four,
    Five
}
```

And I would like to implement the following logic using `switch`:

```
One        => "one to three"
Two        => "one to three"
Three      => "one to three"
Four       => "four"
Five       => "five"
all others => throw an Exception
```
Before C# 8.0, I would have written my example using a classic switch statement:

> Heads-up, if you don't know: `[Theory]` and `[InlindeData]` are Attributes used by `xunit`, a dotnet testing framework. You can ignore it, it's not important to the discussion I would like to initiate. (I had to make sure that my logic is correct, before we can discuss, right 😉)



```csharp
[Theory]
[InlineData(Cases.One, "one to three")]
[InlineData(Cases.Two, "one to three")]
[InlineData(Cases.Three, "one to three")]
[InlineData(Cases.Four, "four")]
[InlineData(Cases.Five, "five")]
public void SwitchStatement(Cases? input, string expected)
{
    string actual;
    switch (input)
    {
        case Cases.One:
        case Cases.Two:
        case Cases.Three:
            actual = "one to three";
            break;
        case Cases.Four:
            actual = "four";
            break;
        case Cases.Five:
            actual = "five";
            break;
        default:
            throw new InvalidEnumArgumentException();
    }

    Assert.Equal(expected, actual);
}
```

With C# 8.0 we did get switch expressions. Now we could write it like so:

```csharp
[Theory]
[InlineData(Cases.One, "one to three")]
[InlineData(Cases.Two, "one to three")]
[InlineData(Cases.Three, "one to three")]
[InlineData(Cases.Four, "four")]
[InlineData(Cases.Five, "five")]
public void SwitchExpression(Cases? input, string expected)
{
    var actual = input switch
    {
        Cases.One => "one to three",
        Cases.Two => "one to three",
        Cases.Three => "one to three",
        Cases.Four => "four",
        Cases.Five => "five",
        _ => throw new InvalidEnumArgumentException()
    };

    Assert.Equal(expected, actual);
}
```

Or we can also combine cases `One`, `Two` and `Three` using `when`:

```csharp
[Theory]
[InlineData(Cases.One, "one to three")]
[InlineData(Cases.Two, "one to three")]
[InlineData(Cases.Three, "one to three")]
[InlineData(Cases.Four, "four")]
[InlineData(Cases.Five, "five")]
public void SwitchExpressionWhen(Cases input, string expected)
{
    var actual = input switch
    {
        var x when x == Cases.One || x == Cases.Two || x == Cases.Three => "one to three",
        Cases.Four => "four",
        Cases.Five => "five",
        _ => throw new InvalidEnumArgumentException()
    };

    Assert.Equal(expected, actual);
}
```

We could also combine 1 to 3 using `when` in a diffrent variation using an Array and `Contains()`:

```csharp
[Theory]
[InlineData(Cases.One, "one to three")]
[InlineData(Cases.Two, "one to three")]
[InlineData(Cases.Three, "one to three")]
[InlineData(Cases.Four, "four")]
[InlineData(Cases.Five, "five")]
public void SwitchExpressionContains(Cases input, string expected)
{
    var actual = input switch
    {
        var x when new[] {Cases.One, Cases.Two, Cases.Three}.Contains(x) => "one to three",
        Cases.Four => "four",
        Cases.Five => "five",
        _ => throw new InvalidEnumArgumentException()
    };

    Assert.Equal(expected, actual);
}
```

❔ Which one of the examples do you prefer? Which one is the most readable to you? Or do you have an even nicer variation to share?


📊 I would like to gather the results in a poll. Do you mind giving your vote?

{% twitter 1238049841927905280 %}