C# switch文の使い方を完全解説｜基本構文・switch式・case条件・よくあるエラーまでわかる

はじめに

C#で条件分岐を書くとき、最初に思い浮かぶのはif文かもしれません。しかし、1つの値に対して複数の候補を比較する場合は、switch文を使うとコードが読みやすくなります。

たとえば、メニュー番号、ステータスコード、曜日、ユーザー権限、処理状態などを分岐したい場面では、switchが非常に便利です。

C#
int menu = 2;

switch (menu)
{
    case 1:
        Console.WriteLine("新規作成");
        break;
    case 2:
        Console.WriteLine("編集");
        break;
    case 3:
        Console.WriteLine("削除");
        break;
    default:
        Console.WriteLine("不明なメニューです");
        break;
}

C#のswitchは、単純な値の比較だけでなく、文字列、enum、型判定、範囲条件、when句、パターンマッチング、switch式など、さまざまな書き方に対応しています。Microsoft公式ドキュメントでも、switch文とswitch式はパターンマッチングを扱う主要な構文として説明されています。

この記事では、C#のswitch文の基本構文から、switch式、case条件、breakやreturnの使い分け、よくあるエラー、実践的な使い方まで順番に解説します。

1. C#のswitch文とは

C#のswitch文とは、ある値や式の結果に応じて、実行する処理を切り替えるための条件分岐構文です。

たとえば、「変数の値が1ならAの処理、2ならBの処理、3ならCの処理」といった分岐を、見やすく整理して書けます。

C#
string role = "Admin";

switch (role)
{
    case "Admin":
        Console.WriteLine("管理者です");
        break;
    case "User":
        Console.WriteLine("一般ユーザーです");
        break;
    case "Guest":
        Console.WriteLine("ゲストです");
        break;
    default:
        Console.WriteLine("不明な権限です");
        break;
}

switch文は、複数の条件を上から順に評価し、最初に一致したcaseの処理を実行します。caseに一致しない場合は、defaultがあればその処理が実行されます。

1-1. switch文でできること

C#のswitch文では、主に次のようなことができます。

1つの値に対して複数の候補を比較できます。

C#
int number = 1;

switch (number)
{
    case 1:
        Console.WriteLine("one");
        break;
    case 2:
        Console.WriteLine("two");
        break;
}

文字列を使った分岐もできます。

C#
string command = "start";

switch (command)
{
    case "start":
        Console.WriteLine("開始します");
        break;
    case "stop":
        Console.WriteLine("停止します");
        break;
}

enumと組み合わせて、状態や種類をわかりやすく分岐できます。

C#
enum OrderStatus
{
    Pending,
    Shipped,
    Delivered,
    Canceled
}

OrderStatus status = OrderStatus.Shipped;

switch (status)
{
    case OrderStatus.Pending:
        Console.WriteLine("注文確認中です");
        break;
    case OrderStatus.Shipped:
        Console.WriteLine("発送済みです");
        break;
    case OrderStatus.Delivered:
        Console.WriteLine("配達完了です");
        break;
    case OrderStatus.Canceled:
        Console.WriteLine("キャンセル済みです");
        break;
}

さらに、C#の新しい構文では、範囲条件や型による分岐も書けます。

C#
int score = 85;

switch (score)
{
    case >= 90:
        Console.WriteLine("A");
        break;
    case >= 80:
        Console.WriteLine("B");
        break;
    case >= 70:
        Console.WriteLine("C");
        break;
    default:
        Console.WriteLine("D");
        break;
}

1-2. if文・else if文との違い

if文は、自由な条件式を書ける汎用的な条件分岐です。

C#
if (score >= 90)
{
    Console.WriteLine("A");
}
else if (score >= 80)
{
    Console.WriteLine("B");
}
else
{
    Console.WriteLine("C");
}

一方、switch文は「1つの対象を複数のパターンと照合する」場面に向いています。

C#
switch (score)
{
    case >= 90:
        Console.WriteLine("A");
        break;
    case >= 80:
        Console.WriteLine("B");
        break;
    default:
        Console.WriteLine("C");
        break;
}

if文は複雑な条件を柔軟に書けますが、条件が増えると読みづらくなりやすいです。switch文は、条件の対象が明確な場合に、分岐を一覧化しやすいのが特徴です。

たとえば、次のようなelse ifが長く続くコードは、switchに置き換えると見通しがよくなります。

C#
if (command == "create")
{
    Create();
}
else if (command == "update")
{
    Update();
}
else if (command == "delete")
{
    Delete();
}
else
{
    ShowError();
}

switchで書くと次のようになります。

C#
switch (command)
{
    case "create":
        Create();
        break;
    case "update":
        Update();
        break;
    case "delete":
        Delete();
        break;
    default:
        ShowError();
        break;
}

1-3. switch文を使うべきケース

switch文は、次のようなケースで使うと効果的です。

値の候補が決まっている場合は、switchが向いています。

C#
switch (day)
{
    case "Monday":
        Console.WriteLine("月曜日");
        break;
    case "Tuesday":
        Console.WriteLine("火曜日");
        break;
    case "Wednesday":
        Console.WriteLine("水曜日");
        break;
}

enumの値に応じて処理を分ける場合も、switchが適しています。

C#
switch (status)
{
    case OrderStatus.Pending:
        ConfirmOrder();
        break;
    case OrderStatus.Shipped:
        TrackShipment();
        break;
    case OrderStatus.Canceled:
        ShowCancelReason();
        break;
}

メニューやコマンドを分岐する処理にも使いやすいです。

C#
switch (input)
{
    case "1":
        ShowList();
        break;
    case "2":
        AddItem();
        break;
    case "3":
        DeleteItem();
        break;
    default:
        Console.WriteLine("正しい番号を入力してください");
        break;
}

条件が「同じ変数に対する比較」で統一されているなら、ifよりswitchのほうが読みやすくなることが多いです。

1-4. switch文を使わないほうがよいケース

一方で、すべての条件分岐をswitchで書けばよいわけではありません。

複雑な条件が組み合わさっている場合は、if文のほうが自然です。

C#
if (age >= 20 && hasLicense && !isExpired)
{
    Console.WriteLine("利用できます");
}

このように、複数の変数を使った条件や、ビジネスルールが複雑な条件では、無理にswitchにすると逆に読みづらくなります。

また、caseが非常に多くなり、各処理が大きくなる場合も注意が必要です。

C#
switch (type)
{
    case "A":
        // 長い処理
        break;
    case "B":
        // 長い処理
        break;
    case "C":
        // 長い処理
        break;
}

このような場合は、メソッドに分割したり、辞書、ポリモーフィズム、Strategyパターンなどを検討したほうがよいことがあります。

2. C# switch文の基本構文

C#のswitch文の基本構文は次のとおりです。

C#
switch (式)
{
    case 値1:
        // 値1に一致したときの処理
        break;

    case 値2:
        // 値2に一致したときの処理
        break;

    default:
        // どのcaseにも一致しなかったときの処理
        break;
}

switchの丸括弧内に判定したい値や式を書き、caseごとに一致したときの処理を書きます。

2-1. switch・case・break・defaultの役割

switchは、分岐の対象となる値を指定するキーワードです。

C#
switch (number)

caseは、対象の値と比較する候補を指定します。

C#
case 1:

breakは、現在のswitch文から抜けるために使います。

C#
break;

defaultは、どのcaseにも一致しなかった場合に実行されます。

C#
default:
    Console.WriteLine("該当なし");
    break;

基本的には、各caseの最後にbreakを書くと覚えておけば問題ありません。ただし、returnやthrowで処理を終了する場合は、breakを書かなくても構いません。

2-2. 数値で分岐する基本例

数値で分岐する例を見てみましょう。

C#
int rank = 2;

switch (rank)
{
    case 1:
        Console.WriteLine("金メダル");
        break;
    case 2:
        Console.WriteLine("銀メダル");
        break;
    case 3:
        Console.WriteLine("銅メダル");
        break;
    default:
        Console.WriteLine("入賞外");
        break;
}

この場合、rankは2なので、次の処理が実行されます。

C#
Console.WriteLine("銀メダル");

数値によるswitchは、メニュー番号、ステータスコード、分類IDなどを処理するときによく使われます。

2-3. 文字列で分岐する基本例

C#のswitch文では、文字列を使った分岐もできます。

C#
string command = "save";

switch (command)
{
    case "new":
        Console.WriteLine("新規作成します");
        break;
    case "save":
        Console.WriteLine("保存します");
        break;
    case "exit":
        Console.WriteLine("終了します");
        break;
    default:
        Console.WriteLine("不明なコマンドです");
        break;
}

文字列のswitchは、ユーザー入力、APIのパラメータ、コマンド名などを判定するときに便利です。

ただし、文字列比較では大文字・小文字の違いに注意が必要です。

C#
string command = "Save";

switch (command)
{
    case "save":
        Console.WriteLine("保存します");
        break;
    default:
        Console.WriteLine("一致しません");
        break;
}

この場合、"Save"と"save"は別の文字列なので一致しません。大文字・小文字を無視したい場合は、事前に変換しておく方法があります。

C#
string command = "Save";

switch (command.ToLower())
{
    case "save":
        Console.WriteLine("保存します");
        break;
}

ただし、commandがnullの可能性がある場合、ToLower()を呼ぶとNullReferenceExceptionが発生します。安全に書くなら、次のようにします。

C#
switch (command?.ToLower())
{
    case "save":
        Console.WriteLine("保存します");
        break;
    default:
        Console.WriteLine("不明なコマンドです");
        break;
}

2-4. enumで分岐する基本例

enumは、決まった値の集合を表す型です。switchと非常に相性がよく、状態管理や種別判定でよく使われます。

C#
enum PaymentStatus
{
    Unpaid,
    Paid,
    Refunded
}

このenumをswitchで分岐してみます。

C#
PaymentStatus status = PaymentStatus.Paid;

switch (status)
{
    case PaymentStatus.Unpaid:
        Console.WriteLine("未払いです");
        break;
    case PaymentStatus.Paid:
        Console.WriteLine("支払い済みです");
        break;
    case PaymentStatus.Refunded:
        Console.WriteLine("返金済みです");
        break;
    default:
        Console.WriteLine("不明な支払い状態です");
        break;
}

enumを使うと、1や2のような意味のわかりにくい数値ではなく、PaymentStatus.Paidのように意味のある名前で分岐できます。

これは、可読性と保守性の向上につながります。

2-5. defaultを省略できるケースと書くべきケース

defaultは必須ではありません。次のように省略できます。

C#
switch (status)
{
    case PaymentStatus.Unpaid:
        Console.WriteLine("未払いです");
        break;
    case PaymentStatus.Paid:
        Console.WriteLine("支払い済みです");
        break;
}

ただし、実務ではdefaultを書いたほうがよいケースが多いです。

たとえば、想定外の値が入ったときにログを出したり、例外を投げたりできます。

C#
switch (status)
{
    case PaymentStatus.Unpaid:
        Console.WriteLine("未払いです");
        break;
    case PaymentStatus.Paid:
        Console.WriteLine("支払い済みです");
        break;
    case PaymentStatus.Refunded:
        Console.WriteLine("返金済みです");
        break;
    default:
        throw new InvalidOperationException("不明な支払い状態です");
}

特にenumを使っている場合でも、キャストによって定義外の値が入る可能性があります。

C#
PaymentStatus status = (PaymentStatus)999;

そのため、想定外の値を検出したい場合はdefaultを書くのがおすすめです。

一方で、何もしないことが明確な場合は、defaultを省略しても問題ありません。ただし、「書き忘れ」なのか「意図的な省略」なのかがわかるように、コメントを書くと親切です。

C#
switch (status)
{
    case PaymentStatus.Paid:
        SendReceipt();
        break;

    // その他の状態では処理しない
}

3. caseの書き方と条件指定

C#のcaseには、単純な値だけでなく、パターンや条件を指定できます。

基本形は次のとおりです。

C#
switch (value)
{
    case 条件:
        // 処理
        break;
}

以前のC#では、caseに書ける内容は定数値が中心でした。しかし現在のC#では、パターンマッチングにより、型、範囲、プロパティ、条件付き分岐なども扱えます。C#のパターンには、型パターン、定数パターン、関係パターン、プロパティパターン、タプルパターン、discardパターンなどがあります。

3-1. caseに指定できる値

基本的なcaseには、数値、文字、文字列、enumなどを指定できます。

C#
int value = 10;

switch (value)
{
    case 0:
        Console.WriteLine("ゼロ");
        break;
    case 10:
        Console.WriteLine("十");
        break;
}

文字も指定できます。

C#
char grade = 'A';

switch (grade)
{
    case 'A':
        Console.WriteLine("優秀");
        break;
    case 'B':
        Console.WriteLine("良好");
        break;
}

文字列も指定できます。

C#
string color = "red";

switch (color)
{
    case "red":
        Console.WriteLine("赤");
        break;
    case "blue":
        Console.WriteLine("青");
        break;
}

enumも指定できます。

C#
switch (status)
{
    case PaymentStatus.Paid:
        Console.WriteLine("支払い済み");
        break;
}

さらに、nullもcaseで判定できます。

C#
string? name = null;

switch (name)
{
    case null:
        Console.WriteLine("名前がありません");
        break;
    default:
        Console.WriteLine(name);
        break;
}

3-2. 複数のcaseで同じ処理を実行する方法

複数のcaseで同じ処理をしたい場合は、caseを連続して書きます。

C#
int month = 1;

switch (month)
{
    case 12:
    case 1:
    case 2:
        Console.WriteLine("冬です");
        break;

    case 3:
    case 4:
    case 5:
        Console.WriteLine("春です");
        break;

    case 6:
    case 7:
    case 8:
        Console.WriteLine("夏です");
        break;

    case 9:
    case 10:
    case 11:
        Console.WriteLine("秋です");
        break;

    default:
        Console.WriteLine("正しい月ではありません");
        break;
}

この書き方では、12、1、2のいずれかに一致した場合、同じ処理が実行されます。

C#では、処理を持たない空のcaseを連続させることはできます。ただし、処理を書いたcaseから次のcaseへそのまま流れるフォールスルーは制限されています。

3-3. caseで範囲条件を指定する方法

C#の関係パターンを使うと、caseで範囲条件を書けます。

C#
int score = 82;

switch (score)
{
    case >= 90:
        Console.WriteLine("A");
        break;
    case >= 80:
        Console.WriteLine("B");
        break;
    case >= 70:
        Console.WriteLine("C");
        break;
    case >= 60:
        Console.WriteLine("D");
        break;
    default:
        Console.WriteLine("F");
        break;
}

この例では、scoreが82なので、case >= 80:に一致します。

範囲を明確に書きたい場合は、andを使えます。

C#
int score = 75;

switch (score)
{
    case >= 80 and <= 100:
        Console.WriteLine("高得点");
        break;
    case >= 60 and < 80:
        Console.WriteLine("合格");
        break;
    case >= 0 and < 60:
        Console.WriteLine("不合格");
        break;
    default:
        Console.WriteLine("不正な点数です");
        break;
}

and、or、notを使った論理パターンにより、複数の条件を組み合わせて書けます。

3-4. when句で条件を追加する方法

when句を使うと、caseに追加条件を付けられます。

C#
int score = 95;
bool isAttendanceGood = true;

switch (score)
{
    case >= 90 when isAttendanceGood:
        Console.WriteLine("評価A");
        break;
    case >= 90:
        Console.WriteLine("点数は高いですが、出席状況を確認してください");
        break;
    default:
        Console.WriteLine("通常評価です");
        break;
}

case >= 90 when isAttendanceGood:は、「scoreが90以上」かつ「isAttendanceGoodがtrue」の場合に一致します。

when句は、型パターンと組み合わせることもできます。

C#
object value = "hello";

switch (value)
{
    case string text when text.Length >= 5:
        Console.WriteLine("5文字以上の文字列です");
        break;
    case string text:
        Console.WriteLine("短い文字列です");
        break;
    default:
        Console.WriteLine("文字列ではありません");
        break;
}

whenを使うと柔軟な条件分岐ができますが、条件が複雑になりすぎると読みづらくなります。複雑な判定はメソッドに切り出すとよいでしょう。

C#
switch (user)
{
    case User u when CanAccessAdminPage(u):
        Console.WriteLine("管理画面にアクセスできます");
        break;
}

3-5. null判定をswitchで行う方法

switchでは、nullを明示的に判定できます。

C#
string? message = null;

switch (message)
{
    case null:
        Console.WriteLine("メッセージがありません");
        break;
    case "":
        Console.WriteLine("空文字です");
        break;
    default:
        Console.WriteLine(message);
        break;
}

nullと空文字は別物です。

C#
string? a = null;
string b = "";

nullは値が存在しない状態、空文字は長さ0の文字列です。そのため、必要に応じて別々に判定します。

when句を使って、空白文字も含めて判定することもできます。

C#
string? input = "   ";

switch (input)
{
    case null:
        Console.WriteLine("nullです");
        break;
    case string s when string.IsNullOrWhiteSpace(s):
        Console.WriteLine("空白です");
        break;
    default:
        Console.WriteLine("入力があります");
        break;
}

ただし、この例ではcase nullを先に書いています。string.IsNullOrWhiteSpace自体はnullも扱えますが、switchの分岐を読みやすくするためにnullを明示するのはよい書き方です。

3-6. defaultとcase _の違い

defaultとcase _は、どちらも「その他」を扱うように見えますが、意味と評価のされ方に違いがあります。

defaultは、どのcaseにも一致しなかった場合に実行されます。

C#
switch (value)
{
    case 1:
        Console.WriteLine("1です");
        break;
    default:
        Console.WriteLine("その他です");
        break;
}

一方、case _はdiscardパターンで、「任意の値に一致するパターン」です。

C#
switch (value)
{
    case 1:
        Console.WriteLine("1です");
        break;
    case _:
        Console.WriteLine("その他です");
        break;
}

この例では、実質的にdefaultと同じように使えます。

ただし、case _は通常のcaseと同じく、上から順に評価されます。そのため、先頭に書くと後続のcaseに到達できなくなります。

C#
switch (value)
{
    case _:
        Console.WriteLine("すべてここに入ります");
        break;

    // このcaseは到達不能になります
    case 1:
        Console.WriteLine("1です");
        break;
}

switch文で「どれにも一致しない場合」を表したいだけなら、基本的にはdefaultを使うと読みやすいです。

一方、switch式ではdefaultではなく_を使うのが一般的です。

C#
string result = value switch
{
    1 => "1です",
    _ => "その他です"
};

4. break・return・throw・gotoの使い方

C#のswitch文では、各caseの処理をどのように終了させるかが重要です。よく使うのはbreakですが、状況によってはreturn、throw、goto case、goto defaultも使えます。

4-1. breakが必要な理由

breakは、switch文から抜けるためのキーワードです。

C#
int value = 1;

switch (value)
{
    case 1:
        Console.WriteLine("1です");
        break;
    case 2:
        Console.WriteLine("2です");
        break;
}

case 1に一致したあと、breakによってswitch文の外へ抜けます。

C#では、処理があるcaseから次のcaseへそのまま流れるフォールスルーは基本的に許可されていません。そのため、breakを書き忘れるとコンパイルエラーになります。

C#
switch (value)
{
    case 1:
        Console.WriteLine("1です");
    case 2:
        Console.WriteLine("2です");
        break;
}

このようなコードはエラーになります。

C言語などでは、breakを書き忘れると次のcaseまで実行されることがあります。しかしC#では、それによるバグを防ぐため、明示的に終了処理を書く必要があります。

4-2. returnでswitchを抜ける書き方

メソッドの中でswitchを使っている場合、returnでメソッド自体を終了できます。

C#
string GetDayName(int day)
{
    switch (day)
    {
        case 1:
            return "月曜日";
        case 2:
            return "火曜日";
        case 3:
            return "水曜日";
        default:
            return "不明な曜日";
    }
}

この場合、各caseでreturnしているため、breakは不要です。

値を返す処理では、breakよりreturnのほうがシンプルに書けることがあります。

C#
bool IsWeekend(DayOfWeek day)
{
    switch (day)
    {
        case DayOfWeek.Saturday:
        case DayOfWeek.Sunday:
            return true;
        default:
            return false;
    }
}

ただし、処理の途中で何度もreturnすると、流れが追いにくくなることもあります。短いメソッドでは便利ですが、長いメソッドでは注意しましょう。

4-3. throwで例外を投げる書き方

想定外の値が来た場合は、throwで例外を投げることがあります。

C#
string GetStatusMessage(PaymentStatus status)
{
    switch (status)
    {
        case PaymentStatus.Unpaid:
            return "未払い";
        case PaymentStatus.Paid:
            return "支払い済み";
        case PaymentStatus.Refunded:
            return "返金済み";
        default:
            throw new ArgumentOutOfRangeException(nameof(status), status, "不明なステータスです");
    }
}

defaultで例外を投げておくと、予期しない値が入ったときに問題を早く発見できます。

特にenumでは、定義されていない値がキャストで入ることがあります。

C#
PaymentStatus status = (PaymentStatus)999;

このような値を静かに無視すると、後から原因を追いにくいバグになります。想定外の値を許容しない設計なら、defaultで例外を投げるのが有効です。

4-4. goto case・goto defaultの使い方

C#のswitchでは、goto caseやgoto defaultを使って、別のcaseへ明示的に移動できます。

C#
int value = 1;

switch (value)
{
    case 1:
        Console.WriteLine("1の処理");
        goto case 2;

    case 2:
        Console.WriteLine("2の処理");
        break;

    default:
        Console.WriteLine("その他");
        break;
}

このコードでは、case 1の処理を実行したあと、case 2の処理に移動します。

goto defaultも使えます。

C#
switch (value)
{
    case 1:
        Console.WriteLine("1の処理");
        goto default;

    default:
        Console.WriteLine("共通処理");
        break;
}

ただし、goto caseやgoto defaultは多用しないほうがよいです。処理の流れが複雑になり、読みづらくなるためです。

複数のcaseで同じ処理をしたいだけなら、次のようにcaseを並べるほうが自然です。

C#
switch (value)
{
    case 1:
    case 2:
        Console.WriteLine("1または2です");
        break;
}

共通処理があるなら、メソッドに切り出す方法もおすすめです。

C#
switch (value)
{
    case 1:
        DoCommon();
        DoA();
        break;
    case 2:
        DoCommon();
        DoB();
        break;
}

4-5. C#でフォールスルーが制限される理由

フォールスルーとは、あるcaseの処理が終わったあと、次のcaseへそのまま流れて実行されることです。

C言語などでは、breakを書き忘れると意図せず次のcaseが実行されることがあります。

C
switch (value)
{
    case 1:
        printf("1");
    case 2:
        printf("2");
        break;
}

このような挙動は、バグの原因になりやすいです。

C#では、処理を持つcaseから次のcaseへ暗黙的に流れることを制限しています。そのため、break、return、throw、gotoなどで、どこへ制御を移すのか明示する必要があります。

C#
switch (value)
{
    case 1:
        Console.WriteLine("1");
        break;

    case 2:
        Console.WriteLine("2");
        break;
}

この仕様により、breakの書き忘れによる予期しない実行を防ぎやすくなっています。

5. C#のswitch式の使い方

C#には、従来のswitch文に加えて、値を返すためのswitch式があります。

switch文は「処理を分岐する」ために使います。

C#
switch (status)
{
    case 1:
        Console.WriteLine("有効");
        break;
    case 2:
        Console.WriteLine("無効");
        break;
}

一方、switch式は「分岐結果として値を返す」ために使います。

C#
string message = status switch
{
    1 => "有効",
    2 => "無効",
    _ => "不明"
};

switch式は、値の変換、メッセージ生成、分類処理などで非常に便利です。Microsoft公式ドキュメントでも、switch式は入力式に対するパターンマッチに基づいて1つの式を評価する構文として説明されています。

5-1. switch文とswitch式の違い

switch文とswitch式の大きな違いは、文か式かです。

switch文は処理を実行します。

C#
switch (level)
{
    case 1:
        Console.WriteLine("初心者");
        break;
    case 2:
        Console.WriteLine("中級者");
        break;
    default:
        Console.WriteLine("不明");
        break;
}

switch式は値を返します。

C#
string levelName = level switch
{
    1 => "初心者",
    2 => "中級者",
    _ => "不明"
};

switch文ではcase、break、defaultを使います。

switch式ではcaseやbreakは使わず、=>と,を使います。また、その他の値を表すときはdefaultではなく_を使います。

switch式は短く書けますが、複雑な処理を詰め込みすぎると読みにくくなります。単純な変換処理にはswitch式、複数行の処理にはswitch文という使い分けが基本です。

5-2. switch式の基本構文

switch式の基本構文は次のとおりです。

C#
var result = value switch
{
    パターン1 => 結果1,
    パターン2 => 結果2,
    _ => デフォルト結果
};

具体例を見てみましょう。

C#
int code = 200;

string message = code switch
{
    200 => "OK",
    400 => "Bad Request",
    404 => "Not Found",
    500 => "Internal Server Error",
    _ => "Unknown"
};

Console.WriteLine(message);

codeが200なので、messageには"OK"が入ります。

switch式の各行は「switchアーム」と呼ばれます。各アームは、パターン、=>、結果の式で構成されます。

C#
200 => "OK"

最後のアームにも,を付けることが多いです。

C#
_ => "Unknown",

最後の,は省略できますが、後から行を追加しやすくなるため、付けておく書き方がよく使われます。

5-3. 値を返すswitch式のサンプル

switch式は、値の変換処理で特に便利です。

C#
DayOfWeek day = DayOfWeek.Monday;

string japanese = day switch
{
    DayOfWeek.Monday => "月曜日",
    DayOfWeek.Tuesday => "火曜日",
    DayOfWeek.Wednesday => "水曜日",
    DayOfWeek.Thursday => "木曜日",
    DayOfWeek.Friday => "金曜日",
    DayOfWeek.Saturday => "土曜日",
    DayOfWeek.Sunday => "日曜日",
    _ => "不明"
};

メソッドの戻り値として直接返すこともできます。

C#
string GetDayName(DayOfWeek day)
{
    return day switch
    {
        DayOfWeek.Monday => "月曜日",
        DayOfWeek.Tuesday => "火曜日",
        DayOfWeek.Wednesday => "水曜日",
        DayOfWeek.Thursday => "木曜日",
        DayOfWeek.Friday => "金曜日",
        DayOfWeek.Saturday => "土曜日",
        DayOfWeek.Sunday => "日曜日",
        _ => "不明"
    };
}

switch文で書くよりも短く、変換の対応関係が見やすくなります。

5-4. ラムダ風の=>を使う書き方

switch式では、=>を使って「このパターンならこの値を返す」と書きます。

C#
string result = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _ => "D"
};

=>の右側には式を書きます。

C#
int point = rank switch
{
    1 => 100,
    2 => 80,
    3 => 60,
    _ => 0
};

メソッド呼び出しも書けます。

C#
string message = status switch
{
    PaymentStatus.Unpaid => CreateUnpaidMessage(),
    PaymentStatus.Paid => CreatePaidMessage(),
    PaymentStatus.Refunded => CreateRefundedMessage(),
    _ => CreateUnknownMessage()
};

ただし、=>の右側に複数行の命令文をそのまま書くことはできません。複雑な処理が必要な場合は、メソッドに切り出すか、switch文を使いましょう。

5-5. discardパターン「_」の使い方

switch式では、どのパターンにも一致しなかった場合を表すために_をよく使います。

C#
string message = code switch
{
    200 => "成功",
    400 => "リクエストエラー",
    404 => "見つかりません",
    _ => "不明なステータス"
};

_はdiscardパターンと呼ばれ、任意の値に一致します。

_を書かない場合、すべての可能性を網羅できていないと警告が出ることがあります。また、実行時にどのアームにも一致しない場合、例外が発生する可能性があります。

C#
string message = code switch
{
    200 => "成功",
    400 => "エラー"
};

このコードでcodeが500だった場合、該当するアームがありません。安全に書くためには、通常は_を用意します。

C#
string message = code switch
{
    200 => "成功",
    400 => "エラー",
    _ => "不明"
};

ただし、想定外の値を明確にエラーにしたい場合は、_で例外を投げるのもよい方法です。

5-6. switch式で例外を投げる方法

switch式でも、throw式を使って例外を投げられます。

C#
string GetStatusMessage(PaymentStatus status)
{
    return status switch
    {
        PaymentStatus.Unpaid => "未払い",
        PaymentStatus.Paid => "支払い済み",
        PaymentStatus.Refunded => "返金済み",
        _ => throw new ArgumentOutOfRangeException(nameof(status), status, "不明なステータスです")
    };
}

この書き方は、enumの変換処理でよく使われます。

_ => "不明"とするか、_ => throw ...とするかは、設計によって決めます。

画面表示などで不明な値をそのまま扱いたい場合は、文字列を返してもよいでしょう。

C#
_ => "不明"

一方、システム上ありえない値なら、例外を投げて早く検知したほうが安全です。

C#
_ => throw new InvalidOperationException("想定外の値です")

5-7. switch式を使うとコードが短くなる例

従来のswitch文で値を返す処理を書くと、次のようになります。

C#
string GetRankName(int rank)
{
    switch (rank)
    {
        case 1:
            return "ゴールド";
        case 2:
            return "シルバー";
        case 3:
            return "ブロンズ";
        default:
            return "ノーマル";
    }
}

switch式で書くと、より短くなります。

C#
string GetRankName(int rank)
{
    return rank switch
    {
        1 => "ゴールド",
        2 => "シルバー",
        3 => "ブロンズ",
        _ => "ノーマル"
    };
}

さらに、式形式のメソッドにすればもっと簡潔にできます。

C#
string GetRankName(int rank) => rank switch
{
    1 => "ゴールド",
    2 => "シルバー",
    3 => "ブロンズ",
    _ => "ノーマル"
};

このように、単純な値変換ではswitch式を使うとコードが短くなり、対応関係も見やすくなります。

ただし、処理が複雑な場合は無理に短くしないことが大切です。読みやすさを優先して、switch文やメソッド分割を選びましょう。

6. パターンマッチングを使ったswitch

C#のswitchは、パターンマッチングと組み合わせることで、単純な値比較以上の分岐ができます。

パターンマッチングとは、値が特定の形や条件に合っているかを判定する仕組みです。C#では、型パターン、プロパティパターン、タプルパターン、関係パターン、論理パターンなどを使えます。

6-1. 型パターンで分岐する方法

型パターンを使うと、オブジェクトの実際の型によって分岐できます。

C#
object value = "Hello";

switch (value)
{
    case string text:
        Console.WriteLine($"文字列です: {text}");
        break;
    case int number:
        Console.WriteLine($"整数です: {number}");
        break;
    case bool flag:
        Console.WriteLine($"真偽値です: {flag}");
        break;
    case null:
        Console.WriteLine("nullです");
        break;
    default:
        Console.WriteLine("その他の型です");
        break;
}

case string text:は、valueがstring型なら一致し、その値をtextという変数として使えます。

型判定とキャストを同時にできるため、次のような古い書き方より簡潔です。

C#
if (value is string)
{
    string text = (string)value;
    Console.WriteLine(text);
}

型パターンを使うと、次のように書けます。

C#
if (value is string text)
{
    Console.WriteLine(text);
}

switchと組み合わせると、複数の型に対する処理を整理できます。

6-2. プロパティパターンで分岐する方法

プロパティパターンを使うと、オブジェクトのプロパティの値で分岐できます。

C#
class User
{
    public string Role { get; set; } = "";
    public bool IsActive { get; set; }
}

このUserをswitchで判定してみます。

C#
User user = new User { Role = "Admin", IsActive = true };

switch (user)
{
    case { Role: "Admin", IsActive: true }:
        Console.WriteLine("有効な管理者です");
        break;
    case { Role: "Admin", IsActive: false }:
        Console.WriteLine("無効な管理者です");
        break;
    case { Role: "User", IsActive: true }:
        Console.WriteLine("有効な一般ユーザーです");
        break;
    default:
        Console.WriteLine("その他のユーザーです");
        break;
}

プロパティパターンを使うと、ifでプロパティを何度も参照するより、条件を構造的に書けます。

C#
string message = user switch
{
    { Role: "Admin", IsActive: true } => "有効な管理者",
    { Role: "Admin", IsActive: false } => "無効な管理者",
    { Role: "User", IsActive: true } => "有効なユーザー",
    _ => "その他"
};

ネストしたプロパティも判定できます。

C#
class Order
{
    public Customer Customer { get; set; } = new Customer();
}

class Customer
{
    public string Rank { get; set; } = "";
}

string discount = order switch
{
    { Customer: { Rank: "Gold" } } => "20%割引",
    { Customer: { Rank: "Silver" } } => "10%割引",
    _ => "割引なし"
};

6-3. タプルパターンで複数値を分岐する方法

タプルパターンを使うと、複数の値の組み合わせで分岐できます。

C#
bool isMember = true;
int totalPrice = 12000;

string rank = (isMember, totalPrice) switch
{
    (true, >= 10000) => "会員特別割引",
    (true, >= 5000) => "会員割引",
    (false, >= 10000) => "通常高額購入",
    _ => "通常購入"
};

この例では、isMemberとtotalPriceの2つの値を同時に判定しています。

switch文でもタプルを使えます。

C#
switch (isMember, totalPrice)
{
    case (true, >= 10000):
        Console.WriteLine("会員特別割引");
        break;
    case (true, >= 5000):
        Console.WriteLine("会員割引");
        break;
    case (false, >= 10000):
        Console.WriteLine("通常高額購入");
        break;
    default:
        Console.WriteLine("通常購入");
        break;
}

タプルパターンは、複数の条件を組み合わせるときに便利です。

たとえば、座標の位置を判定できます。

C#
int x = 0;
int y = 5;

string position = (x, y) switch
{
    (0, 0) => "原点",
    (0, _) => "Y軸上",
    (_, 0) => "X軸上",
    (> 0, > 0) => "第1象限",
    (< 0, > 0) => "第2象限",
    (< 0, < 0) => "第3象限",
    (> 0, < 0) => "第4象限"
};

6-4. 関係パターンで大小比較をする方法

関係パターンを使うと、>、>=、<、<=による比較をcaseやswitch式で書けます。

C#
int temperature = 32;

string message = temperature switch
{
    >= 35 => "猛暑日です",
    >= 30 => "真夏日です",
    >= 25 => "夏日です",
    < 0 => "氷点下です",
    _ => "通常の気温です"
};

switch文でも同じように書けます。

C#
switch (temperature)
{
    case >= 35:
        Console.WriteLine("猛暑日です");
        break;
    case >= 30:
        Console.WriteLine("真夏日です");
        break;
    case >= 25:
        Console.WriteLine("夏日です");
        break;
    case < 0:
        Console.WriteLine("氷点下です");
        break;
    default:
        Console.WriteLine("通常の気温です");
        break;
}