What kinds of pattern matching does C# 14 support? Explain type, constant, relational, logical, property (including extended property), positional, var, discard and list patterns, how the compiler checks exhaustiveness and subsumption, and when pattern matching is better or worse than polymorphism.

1. How patterns compile

The compiler lowers patterns into efficient code:

• Type patterns → isinst + null check (one operation; the bound variable is the cast result).
• Constant patterns → equality comparisons (== for primitives, object.Equals for some cases; is null → reference check that ignores operator overloads).
• Relational patterns → comparison instructions.
• Property patterns → null check + property reads (each property read once even if used by several arms, thanks to the decision DAG).
• List patterns → Length/Count check + indexer access ([^1] uses Index support) + Slice for captured slices.
• A whole switch is turned into a decision DAG that shares tests between arms and may use jump tables for dense constants.

2. Exhaustiveness algorithm

The compiler considers the input's domain (all values of the type, plus null for reference/nullable types) and checks whether the union of arms (without when clauses) covers it. For numeric relational patterns it reasons about ranges; for enums, named members don't make it exhaustive (other values are possible); for closed sets of types it can't know a hierarchy is closed, so a discard is needed.

3. Patterns and nullability

Property patterns { } imply not-null (x is { } nonNull is a common non-null test). Nullable flow analysis understands patterns: after if (o is { Customer: { } c }), c is non-null. Type patterns never match null.

4. List patterns details

List patterns require countable (Length/Count) and indexable (this[int] or this[Index]) types; slice patterns .. require Slice/range indexer support to capture (.. var rest). On arrays and strings, capturing a slice allocates a new array/string; on spans it's free.

5. Combining with when

order switch
{
    { Total: > 1000m } when customer.IsVip => 0m,
    ...
}

when is evaluated only if the pattern matched; use it for conditions not expressible as patterns (method calls, cross-variable comparisons). Remember it defeats exhaustiveness analysis for that arm.

6. Performance

Pattern matching is generally as fast as hand-written if chains (often faster, due to shared tests). Type switches over many types are linear isinst checks; virtual dispatch can be faster for very large hierarchies, but for typical result types the difference is negligible.

Try it yourself

1. Write a switch expression over an enum without a discard and call it with (OrderStatus)99.
2. Order arms incorrectly to trigger CS8510.
3. Use list patterns to parse command-line arguments.
4. Implement the same feature with virtual methods and with pattern matching; add a new type and a new operation to each.

using System.Diagnostics;

namespace Advanced.Patterns;

public enum CustomerType { Consumer, Business }
public sealed record Address(string State, string Country);
public sealed record Customer(CustomerType Type, Address Address, string? Abn);
public sealed record Order(Customer Customer, decimal Total, string Category, IReadOnlyList<string> Skus, bool IsCancelled);

public static class Gst
{
    public static decimal For(Order order) => order switch
    {
        { IsCancelled: true }                                        => 0m,
        { Customer.Address.Country: not "AU" }                       => 0m,       // export
        { Skus: [] }                                                 => 0m,       // list pattern
        { Category: "BasicFood" or "Medical" }                       => 0m,       // GST-free categories (simplified)
        { Customer: { Type: CustomerType.Business, Abn: null } }     => throw new InvalidOperationException("Business customer without ABN"),
        { Total: > 0m and var total }                                => decimal.Round(total / 11m, 2), // GST-inclusive price
        { Total: <= 0m }                                             => 0m,
    };

    public static string Describe(object? value) => value switch
    {
        null => "nothing",
        int n when n < 0 => "negative int",
        int and (0 or 1) => "bit",
        int => "int",
        string { Length: 0 } => "empty string",
        string s => $"string of {s.Length}",
        int[] and [var first, .., var last] => $"array {first}..{last}", // type pattern combined with a list pattern
        _ => value.GetType().Name,
    };

    public static string Size(CustomerType type) => type switch
    {
        CustomerType.Consumer => "B2C",
        CustomerType.Business => "B2B",
        _ => throw new UnreachableException($"Unknown customer type {type}"), // enums can hold unnamed values
    };
}

public static class Program
{
    public static void Main()
    {
        var nsw = new Address("NSW", "AU");
        var order = new Order(new Customer(CustomerType.Consumer, nsw, null), 110m, "Hardware", ["H1"], false);
        Console.WriteLine(Gst.For(order));                        // 10.00
        Console.WriteLine(Gst.Describe(new[] { 3, 5, 9 }));       // array 3..9
        Console.WriteLine(Gst.Describe(1));                       // bit
        Console.WriteLine(Gst.Size(CustomerType.Business));

        if (order is { Customer.Address: { State: "NSW" or "VIC" } address }) Console.WriteLine($"East coast: {address.State}");
    }
}