パターン (C# リファレンス)

C# では、C# 7.0 でパターン マッチングが導入されました。 その後、C# の各メジャー バージョンで、パターン マッチング機能が拡張されています。 次の C# 式およびステートメントでは、パターン マッチングがサポートされています。

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

  • 宣言パターン: 式のランタイム型をチェックし、一致が成功した場合は、宣言された変数に式の結果を代入します。 C# 7.0 で導入されました。
  • 型パターン: 式のランタイム型をチェックします。 C# 9.0 で導入されました。
  • 定数パターン: 式の結果が指定された定数と等しいかどうかをテストします。 C# 7.0 で導入されました。
  • リレーショナル パターン: 式の結果と指定された定数を比較します。 C# 9.0 で導入されました。
  • 論理パターン: 式がパターンの論理的な組み合わせと一致するかどうかをテストします。 C# 9.0 で導入されました。
  • プロパティ パターン: 式のプロパティまたはフィールドが入れ子になったパターンに一致するかどうかをテストします。 C# 8.0 で導入されました。
  • 位置指定パターン: 式の結果を分解し、結果の値が入れ子になったパターンに一致するかどうかをテストします。 C# 8.0 で導入されました。
  • var パターン: 任意の式に一致させ、その結果を宣言された変数に代入します。 C# 7.0 で導入されました。
  • 破棄パターン: 任意の式に一致させます。 C# 8.0 で導入されました。

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

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

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

宣言パターンと型パターンを使用して、式のランタイム型が指定された型と互換性があるかどうかをチェックします。 宣言パターンでは、新しいローカル変数を宣言することもできます。 宣言パターンが式に一致すると、次の例に示すように、その変数に変換された式の結果が代入されます。

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

C# 7.0 以降、式の結果が null 以外で、次のいずれかの条件が満たされている場合に、T 型の 宣言パターン が式に一致します。

  • 式の結果のランタイム型は T です。

  • 式の結果のランタイム型は 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 を持つ Null 許容値型です。

  • 式の結果のランタイム型から T 型への、ボックス化変換またはボックス化解除変換が存在します。

次の例は、最後の 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)),
    };
}

C# 9.0 以降、その目的のために、次の例に示すように 型パターン を使用できます。

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 以外で、そのランタイム型が上記のいずれかの条件を満たす場合に、型パターンは式に一致します。

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

定数パターン

C# 7.0 以降、次の例に示すように、定数パターン を使用して、式の結果が指定された定数と等しいかどうかをテストします。

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)),
};

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

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

if (input is null)
{
    return;
}

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

C# 9.0 以降、次の例に示すように、否定された null 定数パターンを使用して null 以外であるかをチェックできます。

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

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

リレーショナル パターン

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

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# 9.0 以降、notand、および 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}."),
    };
    

前の例に示すように、パターンでパターンの連結子を繰り返し使用できます。

and パターン連結子は、or よりも優先順位が高くなります。 次の例に示すように、優先順位を明示的に指定するには、かっこを使用します。

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

注意

パターンがチェックされる順序は定義されていません。 実行時に、or および and パターンの右側の入れ子になったパターンを最初にチェックできます。

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

プロパティ パターン

C# 8.0 以降、次の例に示すように、プロパティ パターン を使用して、入れ子になったパターンに対して、式のプロパティまたはフィールドを一致させます。

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."),
};

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

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 } };

前の例では、C# 9.0 以降で使用できる 2 つの機能 (orパターン連結子レコード型) を使用しています。

C# 10 以降、入れ子になったプロパティまたはプロパティ パターン内のフィールドを参照できます。 たとえば、前の例のメソッドを次の同等のコードにリファクタリングできます。

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

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

位置指定パターン

C# 8.0 以降、次の例に示すように、位置指定パターン を使用して、式の結果を分解し、結果の値を、対応する入れ子になったパターンに対して一致させます。

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,
    };

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

次の例に示すように、位置指定パターンでタプル要素と 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 パターン

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

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 パターン」セクションを参照してください。

破棄パターン

C# 8.0 以降、次の例に示すように、破棄パターン _ を使用して、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 _ を使用します。

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

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

C# 9.0 以降、任意のパターンをかっこで囲むことができます。 一般にそれを行うのは、次の例に示すように、論理パターンの優先順位を強調または変更するためです。

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

C# 言語仕様

詳しくは、次の機能提案メモをご覧ください。

関連項目