パターン マッチング - パターン内のis式とswitch式、および演算子and、or、およびnot

is式、switch ステートメント、および switch 式を使用して、任意の数の特性に対して入力式を照合します。 C# は、宣言、型、定数、リレーショナル、プロパティ、リスト、var、破棄など、複数のパターンをサポートしています。 ブール型のロジック キーワード and、 or、および notを使用して、パターンを組み合わせることができます。

C# 言語リファレンスには、C# 言語の最新リリース バージョンが記載されています。 また、今後の言語リリースのパブリック プレビューの機能に関する初期ドキュメントも含まれています。

このドキュメントでは、言語の最後の 3 つのバージョンまたは現在のパブリック プレビューで最初に導入された機能を特定します。

次の C# 式およびステートメントでは、パターン マッチングがサポートされています。

• is 式
• switch ステートメント
• switch 式

それらの構造体では、入力式を次の任意のパターンと一致させることができます。

• 宣言パターン: 式の実行時の型を確認し、一致が成功した場合は、宣言された変数に式の結果を割り当てます。
• 型パターン: 式の実行時の型を確認します。
• 定数パターン: 式の結果が指定した定数と等しいことをテストします。
• リレーショナル パターン: 式の結果を指定した定数と比較します。
• 論理パターン: 式がパターンの論理的な組み合わせと一致することをテストします。
• プロパティ パターン: 式のプロパティまたはフィールドが入れ子になったパターンと一致することをテストします。
• 位置指定パターン: 式の結果を分解し、結果の値が入れ子になったパターンと一致するかどうかをテストします。
• var パターン: 任意の式と一致し、その結果を宣言された変数に割り当てます。
• 破棄パターン: 任意の式と一致します。
• リスト パターン: 要素のシーケンスが、対応する入れ子になったパターンと一致することをテストします。

論理、プロパティ、位置指定、およびリスト パターンは ''再帰的な'' パターンです。 つまり、それらには入れ子になったパターンを含めることができます。

これらのパターンを使用してデータ ドリブン アルゴリズムを構築する方法の例については、「 チュートリアル: パターン マッチングを使用してアルゴリズムを構築する」を参照してください。

宣言パターンと型パターン

宣言と型パターンを使用して、式の実行時の型が特定の型と互換性があるかどうかを確認します。 宣言パターンを使用すると、新しいローカル変数を宣言することもできます。 宣言パターンが式と一致すると、次の例に示すように、変換された式の結果に変数が割り当てられます。

object greeting = "Hello, World!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: hello, world!
}

式の結果が null 以外で、次のいずれかの条件が満たされている場合に、 型のTが式に一致します。

• 式の結果の実行時の型には、 Tへの ID 変換があります。
• T型はref struct型であり、式からTへの ID 変換があります。
• 式の結果のランタイム型は T 型から派生するか、インターフェイス T を実装するか、または、それから へのTが別に存在します。 この条件では、継承関係とインターフェイスの実装について説明します。 次の例は、この条件が満たされている場合の 2 つのケースを示しています。

  var numbers = new int[] { 10, 20, 30 };
  Console.WriteLine(GetSourceLabel(numbers));  // output: 1
  
  var letters = new List<char> { 'a', 'b', 'c', 'd' };
  Console.WriteLine(GetSourceLabel(letters));  // output: 2
  
  static int GetSourceLabel<T>(IEnumerable<T> source) => source switch
  {
      Array array => 1,
      ICollection<T> collection => 2,
      _ => 3,
  };
  

  前の例では、GetSourceLabel メソッドへの最初の呼び出しで、引数 のランタイム型 int[] が Array 型から派生しているため、最初のパターンが引数値と一致します。 GetSourceLabel メソッドへの 2 つ目の呼び出しでは、引数のランタイム型 List<T> は、Array 型から派生していませんが、ICollection<T> インターフェイスを実装しています。
• 式の結果の実行時型は、基になる型がであるTであり、Nullable<T>.HasValueがtrue。
• 式がのインスタンスでない場合、式の結果の実行時の型から型へのT化またはref structの変換が存在します。

宣言パターンでは、ユーザー定義の変換や暗黙的なスパン変換は考慮されません。

次の例は、最後の 2 つの条件を示しています。

int? xNullable = 7;
int y = 23;
object yBoxed = y;
if (xNullable is int a && yBoxed is int b)
{
    Console.WriteLine(a + b);  // output: 30
}

式の型のみを確認するには、次の例に示すように、変数の名前の代わりに破棄 _ を使用します。

public abstract class Vehicle {}
public class Car : Vehicle {}
public class Truck : Vehicle {}

public static class TollCalculator
{
    public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
    {
        Car _ => 2.00m,
        Truck _ => 7.50m,
        null => throw new ArgumentNullException(nameof(vehicle)),
        _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
    };
}

そのため、次の例に示すように、 型パターンを使用します。

public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
{
    Car => 2.00m,
    Truck => 7.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};

宣言パターンと同様に、式の結果が null 以外で、その実行時の型が上記の条件のいずれかを満たす場合、型パターンは式と一致します。

null 以外を確認するには、次の例に示すように、nullを使用します。

if (input is not null)
{
    // ...
}

詳細については、C# 言語仕様の 宣言パターン と 型パターン のセクションを参照してください。

定数パターン

定数パターンは、右オペランドが定数の場合に==の代替構文です。 次の例に示すように、 定数パターン を使用して、式の結果が指定した定数と等しいかどうかをテストします。

public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
    1 => 12.0m,
    2 => 20.0m,
    3 => 27.0m,
    4 => 32.0m,
    0 => 0.0m,
    _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};

定数パターンでは、次のような任意の定数式を使用できます。

• 整数または浮動小数点数値リテラル
• char
• 文字列リテラル
• ブール値 true または false
• 列挙型値
• 宣言された定数フィールドまたはローカルの名前
• null

式は定数型に変換できる型である必要があります。ただし、1 つの例外があります。型が Span<char> または ReadOnlySpan<char> の式は、定数文字列と照合できます。

次の例に示すように、定数パターンを使用して null をチェックします。

if (input is null)
{
    return;
}

コンパイラは、式の==を評価するときに、ユーザー オーバーロードの等値演算子x is nullを呼び出さないことを保証します。

次の例で示すように、否定されたnull 定数パターンを使って、null ではないことを調べることができます。

if (input is not null)
{
    // ...
}

詳細については、機能提案ノートの「定数パターン」セクションを参照してください。

リレーショナル パターン

次の例に示すように、 リレーショナル パターン を使用して式の結果を定数と比較します。

Console.WriteLine(Classify(13));  // output: Too high
Console.WriteLine(Classify(double.NaN));  // output: Unknown
Console.WriteLine(Classify(2.4));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -4.0 => "Too low",
    > 10.0 => "Too high",
    double.NaN => "Unknown",
    _ => "Acceptable",
};

リレーショナル パターンでは、関係演算子、<、>、<=、または>=のいずれかを使用します。 リレーショナル パターンの右側の部分は、定数式である必要があります。 定数式には、整数、浮動小数点、char、または列挙型を指定できます。

式の結果が特定の範囲内にあるかどうかをチェックするには、次の例に示すように、接続的andパターンに対して、それを一致させます。

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 3, 14)));  // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 7, 19)));  // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 2, 17)));  // output: winter

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    >= 3 and < 6 => "spring",
    >= 6 and < 9 => "summer",
    >= 9 and < 12 => "autumn",
    12 or (>= 1 and < 3) => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

式の結果が null された場合、または null 許容変換またはボックス化解除変換を使用して定数の型に変換できない場合、リレーショナル パターンは式と一致しません。

詳細については、C# 言語仕様の リレーショナル パターン に関するセクションを参照してください。

論理パターン

not、and、およびor パターンの組み合わせ子を使用して、次の論理パターンを作成します。

• 否定されたパターンが式に一致しない場合に、式に一致する否定notパターン。 次の例に、定数null パターンを否定して、式が null でないかどうかを確認する方法を示します。

  if (input is not null)
  {
      // ...
  }
  

• 両方のパターンが式に一致する場合に、式に一致する接続的and パターン。 次の例に、リレーショナル パターンを組み合わせて、値が特定の範囲内にあるかどうかをチェックする方法を示します。

  Console.WriteLine(Classify(13));  // output: High
  Console.WriteLine(Classify(-100));  // output: Too low
  Console.WriteLine(Classify(5.7));  // output: Acceptable
  
  static string Classify(double measurement) => measurement switch
  {
      < -40.0 => "Too low",
      >= -40.0 and < 0 => "Low",
      >= 0 and < 10.0 => "Acceptable",
      >= 10.0 and < 20.0 => "High",
      >= 20.0 => "Too high",
      double.NaN => "Unknown",
  };
  

• 次の例に示すように、いずれかのパターンが式に一致する場合に、式に一致する "離接的" パターン。or

  Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19)));  // output: winter
  Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9)));  // output: autumn
  Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11)));  // output: spring
  
  static string GetCalendarSeason(DateTime date) => date.Month switch
  {
      3 or 4 or 5 => "spring",
      6 or 7 or 8 => "summer",
      9 or 10 or 11 => "autumn",
      12 or 1 or 2 => "winter",
      _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
  };
  

前の例に示すように、パターンの組み合わせ子をパターンで繰り返し使用できます。

優先順位とチェックの順序

パターン コンバイネーターは、式のバインド順序に基づいて、式を次の順序でチェックします。

• not
• and
• or

not パターンは、最初にそのオペランドにバインドされます。 and パターンは、任意のnotパターン式バインドの後にバインドされます。 or パターンは、すべてのnotパターンとand パターンがオペランドにバインドされた後にバインドされます。 次の例では、小文字ではなく、aを使用してzすべての文字を照合しようとします。 not パターンの前にand パターンがバインドされるため、エラーが発生します。

// Incorrect pattern. `not` binds before `and`
static bool IsNotLowerCaseLetter(char c) => c is not >= 'a' and <= 'z';

既定のバインドは、前の例が次の例のように解析されていることを意味します。

// The default binding without parentheses is shows in this method. `not` binds before `and`
static bool IsNotLowerCaseLetterDefaultBinding(char c) => c is ((not >= 'a') and <= 'z');

エラーを修正するには、 not パターンを >= 'a' and <= 'z' 式にバインドするように指定します。

// Correct pattern. Force `and` before `not`
static bool IsNotLowerCaseLetterParentheses(char c) => c is not (>= 'a' and <= 'z');

パターンが複雑になるにつれて、かっこの追加がより重要になります。 一般に、次の例に示すように、かっこを使用して他の開発者のパターンを明確にします。

static bool IsLetter(char c) => c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z');

詳細については、C# 言語仕様の 「パターン コンバイネータ 」セクションを参照してください。

プロパティ パターン

次の例に示すように、 プロパティ パターン を使用して、入れ子になったパターンに対して式のプロパティまたはフィールドを照合します。

static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };

プロパティ パターンは、式の結果が null 以外で、入れ子になったパターンが式の結果の対応するプロパティまたはフィールドと一致する場合に、式と一致します。

次の例に示すように、実行時の型チェックと変数宣言をプロパティ パターンに追加できます。

Console.WriteLine(TakeFive("Hello, world!"));  // output: Hello
Console.WriteLine(TakeFive("Hi!"));  // output: Hi!
Console.WriteLine(TakeFive(new[] { '1', '2', '3', '4', '5', '6', '7' }));  // output: 12345
Console.WriteLine(TakeFive(new[] { 'a', 'b', 'c' }));  // output: abc

static string TakeFive(object input) => input switch
{
    string { Length: >= 5 } s => s.Substring(0, 5),
    string s => s,

    ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
    ICollection<char> symbols => new string(symbols.ToArray()),

    null => throw new ArgumentNullException(nameof(input)),
    _ => throw new ArgumentException("Not supported input type."),
};

このコンストラクトは、具体的には 、空 のプロパティ パターン is { } が null 以外のすべてのものに一致することを意味し、 is not null ではなくそれを使用して変数 somethingPossiblyNull is { } somethingDefinitelyNotNull を作成できます。

if (GetSomeNullableStringValue() is { } nonNullValue) // Empty property pattern with variable creation
{
    Console.WriteLine("NotNull:" + nonNullValue);
}
else
{
    nonNullValue = "NullFallback"; // we can access the variable here.
    Console.WriteLine("it was null, here's the fallback: " + nonNullValue);
}

プロパティ パターンは、再帰的パターンです。 入れ子になったパターンとして任意のパターンを使用できます。 次の例に示すように、入れ子になったパターンに対して、データの一部を一致させるには、プロパティ パターンを使用します。

public record Point(int X, int Y);
public record Segment(Point Start, Point End);

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start: { Y: 0 } } or { End: { Y: 0 } };

前の例では、orパターン連結子とレコード型を使用しています。

入れ子になったプロパティまたはフィールドは、プロパティ パターン内で参照できます。 この機能は "拡張プロパティ パターン" と呼ばれます。 たとえば、前の例のメソッドを次の同等のコードにリファクタリングできます。

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

詳細については、C# 標準の プロパティ パターン に関するセクションを参照してください。

位置指定パターン

次の例に示すように、 位置指定パターン を使用して式を分解し、結果の値を対応する入れ子になったパターンと照合します。

public readonly struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) => (X, Y) = (x, y);

    public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);
}

static string Classify(Point point) => point switch
{
    (0, 0) => "Origin",
    (1, 0) => "positive X basis end",
    (0, 1) => "positive Y basis end",
    _ => "Just a point",
};

前の例では、式の型に Deconstruct メソッドが含まれています。このメソッドは、パターンが式の結果を分解するために使用します。

また、位置指定パターンに対してタプル型の式を一致させることもできます。 この方法を使用すると、次の例に示すように、複数の入力をさまざまなパターンと照合できます。

static decimal GetGroupTicketPriceDiscount(int groupSize, DateTime visitDate)
    => (groupSize, visitDate.DayOfWeek) switch
    {
        (<= 0, _) => throw new ArgumentException("Group size must be positive."),
        (_, DayOfWeek.Saturday or DayOfWeek.Sunday) => 0.0m,
        (>= 5 and < 10, DayOfWeek.Monday) => 20.0m,
        (>= 10, DayOfWeek.Monday) => 30.0m,
        (>= 5 and < 10, _) => 12.0m,
        (>= 10, _) => 15.0m,
        _ => 0.0m,
    };

前の例では、リレーショナル パターンと論理パターンを使用しています。

次の例に示すように、位置指定パターンでタプル要素と Deconstruct パラメーターの名前を使用できます。

var numbers = new List<int> { 1, 2, 3 };
if (SumAndCount(numbers) is (Sum: var sum, Count: > 0))
{
    Console.WriteLine($"Sum of [{string.Join(" ", numbers)}] is {sum}");  // output: Sum of [1 2 3] is 6
}

static (double Sum, int Count) SumAndCount(IEnumerable<int> numbers)
{
    int sum = 0;
    int count = 0;
    foreach (int number in numbers)
    {
        sum += number;
        count++;
    }
    return (sum, count);
}

また、次のいずれかの方法で位置指定パターンを拡張することもできます。

• 次の例に示すように、ランタイム型チェックと変数宣言を追加します。

  public record Point2D(int X, int Y);
  public record Point3D(int X, int Y, int Z);
  
  static string PrintIfAllCoordinatesArePositive(object point) => point switch
  {
      Point2D (> 0, > 0) p => p.ToString(),
      Point3D (> 0, > 0, > 0) p => p.ToString(),
      _ => string.Empty,
  };
  

  前の例では、 メソッドを暗黙的に提供するDeconstructを使用しています。

• 次の例に示すように、位置指定パターン内でプロパティ パターンを使用します。

  public record WeightedPoint(int X, int Y)
  {
      public double Weight { get; set; }
  }
  
  static bool IsInDomain(WeightedPoint point) => point is (>= 0, >= 0) { Weight: >= 0.0 };
  

• 次の例に示すように、上記の 2 つの使用法を組み合わせます。

  if (input is WeightedPoint (> 0, > 0) { Weight: > 0.0 } p)
  {
      // ..
  }
  

位置指定パターンは、再帰的パターンです。 つまり、入れ子になったパターンとして任意のパターンを使用できます。

詳細については、機能提案ノートの「位置指定パターン」セクションを参照してください。

var パターン

次の例に示すように、 var パターン を使用して、 nullを含む任意の式を照合し、その結果を新しいローカル変数に割り当てます。

static bool IsAcceptable(int id, int absLimit) =>
    SimulateDataFetch(id) is var results 
    && results.Min() >= -absLimit 
    && results.Max() <= absLimit;

static int[] SimulateDataFetch(int id)
{
    var rand = new Random();
    return Enumerable
               .Range(start: 0, count: 5)
               .Select(s => rand.Next(minValue: -10, maxValue: 11))
               .ToArray();
}

var パターンは、中間計算の結果を保持するためにブール式内に一時変数が必要な場合に便利です。 さらに、次の例に示すように、var 式またはステートメントの when case guard で追加のチェックを実行する必要がある場合は、switch パターンを使用することもできます。

public record Point(int X, int Y);

static Point Transform(Point point) => point switch
{
    var (x, y) when x < y => new Point(-x, y),
    var (x, y) when x > y => new Point(x, -y),
    var (x, y) => new Point(x, y),
};

static void TestTransform()
{
    Console.WriteLine(Transform(new Point(1, 2)));  // output: Point { X = -1, Y = 2 }
    Console.WriteLine(Transform(new Point(5, 2)));  // output: Point { X = 5, Y = -2 }
}

前の例で、パターン var (x, y) は 位置指定パターン(var x, var y) と同じです。

var パターンでは、宣言された変数の型は、パターンが一致する式のコンパイル時の型です。

詳細については、機能提案ノートの「Var パターン」セクションを参照してください。

破棄パターン

次の例に示すように破棄_を使用して、nullを含む任意の式と一致させます。

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));  // output: 5.0
Console.WriteLine(GetDiscountInPercent(null));  // output: 0.0
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));  // output: 0.0

static decimal GetDiscountInPercent(DayOfWeek? dayOfWeek) => dayOfWeek switch
{
    DayOfWeek.Monday => 0.5m,
    DayOfWeek.Tuesday => 12.5m,
    DayOfWeek.Wednesday => 7.5m,
    DayOfWeek.Thursday => 12.5m,
    DayOfWeek.Friday => 5.0m,
    DayOfWeek.Saturday => 2.5m,
    DayOfWeek.Sunday => 2.0m,
    _ => 0.0m,
};

前の例では、破棄パターンは null と、 DayOfWeek 列挙体の対応するメンバーを持たない整数値を処理します。 この保証により、この例の switch 式で、使用可能なすべての入力値が確実に処理されます。 switch 式で破棄パターンを使用せず、式のパターンが入力に一致しない場合、ランタイムによって、例外がスローされます。 switch 式ですべての可能な入力値が処理されない場合、コンパイラで警告が生成されます。

破棄パターンを、is 式または switch ステートメントでパターンにすることはできません。 そのような場合、任意の式に一致させるには、破棄を含む var パターンvar _ を使用します。 破棄パターンを、switch 式でパターンにすることはできません。

詳細については、機能提案ノートの「破棄パターン」セクションを参照してください。

かっこで囲まれたパターン

任意のパターンをかっこで囲むことができます。 通常は、次の例に示すように、かっこを使用して 論理パターンの優先順位を強調または変更します。

if (input is not (float or double))
{
    return;
}

リスト パターン

次の例に示すように、配列またはリストを一 連 のパターンと照合できます。

int[] numbers = { 1, 2, 3 };

Console.WriteLine(numbers is [1, 2, 3]);  // True
Console.WriteLine(numbers is [1, 2, 4]);  // False
Console.WriteLine(numbers is [1, 2, 3, 4]);  // False
Console.WriteLine(numbers is [0 or 1, <= 2, >= 3]);  // True

前の例に示すように、入れ子になった各パターンが入力シーケンスの対応する要素と一致すると、リスト パターンが一致します。 リスト パターン内では任意のパターンを使用できます。 任意の要素と一致するには、 破棄パターン を使用するか、要素をキャプチャする場合は、次の例に示すように var パターンを使用します。

List<int> numbers = new() { 1, 2, 3 };

if (numbers is [var first, _, _])
{
    Console.WriteLine($"The first element of a three-item list is {first}.");
}
// Output:
// The first element of a three-item list is 1.

上記の例では、入力シーケンス全体をリスト パターンと照合しています。 次の例に示すように、入力シーケンスの先頭または末尾 (またはその両方) でのみ要素を照合するには、 スライス パターン..を使用します。

Console.WriteLine(new[] { 1, 2, 3, 4, 5 } is [> 0, > 0, ..]);  // True
Console.WriteLine(new[] { 1, 1 } is [_, _, ..]);  // True
Console.WriteLine(new[] { 0, 1, 2, 3, 4 } is [> 0, > 0, ..]);  // False
Console.WriteLine(new[] { 1 } is [1, 2, ..]);  // False

Console.WriteLine(new[] { 1, 2, 3, 4 } is [.., > 0, > 0]);  // True
Console.WriteLine(new[] { 2, 4 } is [.., > 0, 2, 4]);  // False
Console.WriteLine(new[] { 2, 4 } is [.., 2, 4]);  // True

Console.WriteLine(new[] { 1, 2, 3, 4 } is [>= 0, .., 2 or 4]);  // True
Console.WriteLine(new[] { 1, 0, 0, 1 } is [1, 0, .., 0, 1]);  // True
Console.WriteLine(new[] { 1, 0, 1 } is [1, 0, .., 0, 1]);  // False

スライス パターンでは 0 個以上の要素を照合します。 リスト パターンでは最大 1 つのスライス パターンを使用できます。 スライス パターンは、リスト パターンでのみ表示できます。

次の例に示すように、スライス パターン内でサブパターンを入れ子にすることもできます。

void MatchMessage(string message)
{
    var result = message is ['a' or 'A', .. var s, 'a' or 'A']
        ? $"Message {message} matches; inner part is {s}."
        : $"Message {message} doesn't match.";
    Console.WriteLine(result);
}

MatchMessage("aBBA");  // output: Message aBBA matches; inner part is BB.
MatchMessage("apron");  // output: Message apron doesn't match.

void Validate(int[] numbers)
{
    var result = numbers is [< 0, .. { Length: 2 or 4 }, > 0] ? "valid" : "not valid";
    Console.WriteLine(result);
}

Validate(new[] { -1, 0, 1 });  // output: not valid
Validate(new[] { -1, 0, 0, 1 });  // output: valid

詳細については、C# 言語仕様の リスト パターン を参照してください。

C# 15 以降では、拡張機能のインデックス作成メンバーは、リスト パターンで必要なカウントと要素のアクセスも提供できます。 例については、「 拡張インデクサー」を参照してください。

閉じた階層パターン

C# 15 以降では、制御型が switch クラスであるclosed式は、そのクラスのすべての直接子孫をアームが処理する際に網羅的です。 スイッチは完全であるため、コンパイラは既定のアームを必要としません。

public closed record class PaymentMethod;
public record class Cash : PaymentMethod;
public record class Card(string Last4) : PaymentMethod;
public record class BankTransfer(string Iban) : PaymentMethod;

public static string Describe(PaymentMethod method) => method switch
{
    Cash => "cash",
    Card(var last4) => $"card ending {last4}",
    BankTransfer(var iban) => $"bank transfer to {iban}",
    // No warning: every direct descendant of 'PaymentMethod' is handled.
};

閉じた階層スイッチは、すべての直接子孫がスイッチの場所から到達可能な場合にのみ網羅的です。 直接の子孫が閉じた基本型よりもアクセスしやすくなく、スイッチ サイトに表示されない場合、コンパイラはそれを未処理として扱い、スイッチが網羅的ではないことを警告します。

たとえば、閉じた public 基底クラスには、 internal 直接子孫を含めることができます。 同じアセンブリ内のコードには子孫の完全なセットが表示されますが、別のアセンブリ内のコードでは次の処理は行われません。

// Assembly 1
public closed record class Shape;
public record class Circle(double Radius) : Shape;
internal record class Triangle(double Base, double Height) : Shape;

// Same assembly: 'Triangle' is visible, so the switch is exhaustive.
internal static double Area(Shape shape) => shape switch
{
    Circle(var r) => Math.PI * r * r,
    Triangle(var b, var h) => 0.5 * b * h,
};

// Assembly 2
public static string Name(Shape shape) => shape switch
{
    Circle => "circle",
    // Warning CS8509: the switch expression doesn't handle all possible values.
    // 'Triangle' is a direct descendant of 'Shape' but isn't visible here.
};

アセンブリ 2 の完全さを復元するには、破棄アーム (_ => ...) を追加するか、基底クラスの arm (前の例でShape ) を追加するか、またはすべての直接子孫を少なくとも閉じた基本型としてアクセスできるようにします。

制御型が null 許容の場合、 null はスイッチが処理する必要がある追加の値です。 PaymentMethod?アームを省略するnullの切り替えは、すべての直接子孫が一致した場合でも網羅的ではありません。

閉じたクラスからの派生は推移的ではありません。閉じたクラスの非閉じた子孫は、他のアセンブリから派生できます。 コンパイラは 、直接 の子孫のみを完全なセットとして扱います。 子孫を切り替える場合も、網羅性チェックの恩恵を受けるために、子孫 closed (または sealed) を宣言します。

間接子孫は閉じたベースの完全なセットを拡張しないため、完全性を満たすためにすべての推移的サブタイプにアームを追加する必要はありません。 アーム間の再開は、どのクラス階層でも同様に機能します。基本型と一致するアームはすべてのサブタイプをカバーし、それらのサブタイプのいずれかに一致する後のアームには到達できません。 直接の子孫がVehicleおよびCarである閉じたTruckに加えて、別のアセンブリで宣言された間接的な子孫Sedan考えてみましょう。

// Assembly 1
public closed record class Vehicle;
public record class Car(int Doors) : Vehicle;
public record class Truck(double PayloadTons) : Vehicle;

// Assembly 2
public record class Sedan(int Doors) : Car(Doors);

Vehicleの切り替えは、Carが存在する場合でも、TruckとSedanを処理した後に完全に実行されます。 Carアームは、すべてのSedan値をカバーします。

public static string Category(Vehicle v) => v switch
{
    Car => "car",
    Truck => "truck",
    // No warning. The 'Car' arm covers 'Sedan' through ordinary subtype matching.
};

特にSedanにディスパッチするには、アームのCar腕を置く必要があります。 Carアームは、CarではないすべてのSedanと引き続き一致するため、到達可能なままになります。

public static string CategorySedanFirst(Vehicle v) => v switch
{
    Sedan => "sedan",
    Car => "car",      // Reachable: 'Car' values that aren't 'Sedan'.
    Truck => "truck",
};

これら 2 つのアームを反転すると、他のクラス階層の場合と同様に、再開エラーが発生します。 コンパイラは、 Car arm が既に Sedanをカバーしていることを検出します。

string Category(Vehicle v) => v switch
{
    Car => "car",
    Sedan => "sedan",  // Error CS8510: the pattern is unreachable. It has already been handled by 'Car => ...'.
    Truck => "truck",
};

階層をさらに完全にフォローする場合は、 Car 自体を closed宣言します。 コンパイラは、 Car のすべての直接子孫 ( Sedan など) を、 Carに根ざした完全なセットとして扱います。 管理の種類が Car スイッチは、次のいずれかの場合に網羅的です。

• Carのすべての直接子孫を独自の腕で処理します。
• すべてのCar値 (すべてのサブタイプを含む) をカバーするCar arm が含まれます。
• 破棄アーム (_ => ...) または基本タイプの Car用のアーム ( Vehicleなど) が含まれます。

管理の種類がVehicleスイッチには選択肢があります。CarとTruckを処理するコードは、CarのすべてのサブタイプをCar arm がカバーするため、依然として網羅的です。 Car closedマークすると、そのスイッチの 2 つ目のオプションが表示されます。 単一の Car アームを保持するか、 Car の直接の子孫( Truck アームと共に)ごとに1つのアームに置き換えて、それでも完全にすることができます。

また、 Carclosed マークすると暗黙的に abstractされるため、 Car のインスタンスを直接作成できなくなります。 その条件が設計に適合しない可能性があります。 Carを即時に維持する必要がある場合は、開いたままにして、前に示したように腕を注文することで、気になる特定のサブタイプにディスパッチします。

型パラメーターの管理型

閉じた階層機能仕様では、制御型が閉じたクラスに制約された型パラメーターであるswitch式を、閉じたクラス自体の切り替えと同じ用語に完全に定義します。 そのため、ジェネリック コードは、型パラメーターを閉じた基底に制約し、すべての直接子孫を処理することで、閉じた階層にディスパッチできます。

public static string Describe<X>(X method) where X : PaymentMethod => method switch
{
    Cash => "cash",
    Card(var last4) => $"card ending {last4}",
    BankTransfer(var iban) => $"bank transfer to {iban}",
    // No warning: 'X' is constrained to the closed type 'PaymentMethod', so the
    // compiler treats this switch as exhaustive because every direct descendant is handled.
};

詳細については、 閉じた修飾子を参照してください。 仕様については、「 閉じた階層」を参照してください。

共用体パターン

C# 15 では、 共用体型が導入されています。 共用体式に型または宣言パターンを適用すると、パターンは共用体インスタンスではなく共用体の内容をテストします。 たとえば、これらのケースの型はそれぞれ Name プロパティを持ち、 Dog には Breed プロパティもあります。

public record class Cat(string Name);
public record class Dog(string Name, string Breed);

次の Pet 共用体は、独自の読み取り専用の Name プロパティを公開します。このプロパティは、包含ケースにデリゲートします。

public union Pet(Cat, Dog)
{
    public string Name => this switch
    {
        Cat cat => cat.Name,
        Dog dog => dog.Name,
        null => "",
    };
}

型指定された再帰パターンでは、内容もテストされます。含まれている犬のBreedを読み取Dog { Breed: "Labrador" }、共用体に含まれていないプロパティが読み取られます。 これに対し、型指定されていないプロパティと位置指定パターンとリスト パターンでは、共用体インスタンスのメンバーが使用されます。 ここでは、 { Name: "Rex" } は共用体の Name プロパティを読み取るので、その名前の猫または犬のいずれかと一致します。

Pet pet = new Dog("Rex", "Labrador");
Console.WriteLine(pet is Dog { Breed: "Labrador" }); // output: True
Console.WriteLine(pet is { Name: "Rex" });           // output: True
pet = new Cat("Rex");
Console.WriteLine(pet is Dog { Breed: "Labrador" }); // output: False
Console.WriteLine(pet is { Name: "Rex" });           // output: True

これらの規則は、 is 式と switch 式の両方に適用されます。 破棄 _ パターンは受信共用体と一致し、 var パターンはラップ解除せずにそれをキャプチャします。

null パターンは、共用体の内容が null であるかどうかをチェックします。 また、クラス ベースの共用体参照または null 許容共用体ラッパーが null の場合にも成功します。 not パターンは入れ子になったパターンを否定するため、pet is not nullは null 以外の内容をテストします。 空の型指定されていないプロパティ パターン pet is { }、代わりに共用体インスタンスをテストします。その内容が null の場合でも、null にできない構造体共用体と一致します。

型パターンは、少なくとも 1 つのケース型と互換性がある必要があります。 上記の Pet 宣言では、 pet is Pet は共用体インスタンスをテストするのではなく、コンパイラ エラー CS8121 を生成します。 Petはケース型であるため、union Pet(Cat, Dog, Pet)などの再帰的な宣言に成功する可能性があります。 再帰共用体を使用すると、これらのテストを誤って解釈しやすくなります。このパターンは、外側のインスタンスではなく、含まれている Petをテストします。 非回復的な共用体宣言を優先します。

共用体型が 非ボックス化アクセス パターンを提供する場合、コンパイラは型パターン チェック用に TryGetValue を呼び出し、null パターン チェックに HasValue し、値型の場合はボックス化を回避します。 各メンバーは、独自のパターンの種類に適用されます。どちらも、もう一方のパターンのフォールバックでもありません。 メンバーが見つからない場合、コンパイラは代わりにそのパターンの Value プロパティをチェックします。

詳細については、「 共用体の照合」を参照してください。 仕様については、「 共用体」を参照してください。

C# 言語仕様

詳細については、次のような C# 言語仕様のパターンとパターン マッチングのセクションを参照してください。

• リスト パターン
• スライス パターン
• 定数パターン

関連項目

• C# の演算子と式
• パターン マッチングの概要
• チュートリアル: パターン マッチングを使用してアルゴリズムを構築する