Pattern Matching

public static class WherePatternsAppear
{
    public static string Describe(object value)
    {
        if (value is int count && count > 0)        // 1. the `is` operator
        {
            return $"positive int {count}";
        }

        switch (value)                               // 2. a switch statement
        {
            case string { Length: 0 }:
                return "empty string";
            case string s:
                return $"string of {s.Length}";
        }

        return value switch                          // 3. a switch expression
        {
            double d => $"double {d}",
            null => "null",
            _ => value.GetType().Name,
        };
    }
}

public static class SwitchForms
{
    // Statement: side effects, multiple labels per section, explicit break.
    public static void Log(int severity)
    {
        switch (severity)
        {
            case 0:
            case 1:
                Console.WriteLine("informational");
                break;
            case >= 2 and < 5:
                Console.WriteLine("warning");
                break;
            default:
                Console.WriteLine("error");
                break;
        }
    }

    // Expression: one value out, commas not breaks, `_` not `default`.
    public static string Name(int severity) => severity switch
    {
        0 or 1 => "informational",
        >= 2 and < 5 => "warning",
        _ => "error",
    };
}

public static class CaseGuards
{
    public static string Compare(Point p) => p switch
    {
        var (x, y) when x == y => "on the diagonal",
        var (x, y) when x == -y => "on the anti-diagonal",
        ( > 0, > 0) => "quadrant I",
        _ => "elsewhere",
    };

    public static string Sizing(string text, int limit) => text switch
    {
        { Length: 0 } => "empty",
        _ when text.Length > limit => "too long",     // limit is a variable -- not a constant pattern
        _ => "fine",
    };
}

public enum Direction { North, South, East, West }

public static class Exhaustiveness
{
    // Exhaustive over the declared members -- but an enum can legally hold any underlying value,
    // e.g. (Direction)99, so the compiler still wants a fallback.
    public static string ToArrow(Direction d) => d switch
    {
        Direction.North => "↑",
        Direction.South => "↓",
        Direction.East => "→",
        Direction.West => "←",
        _ => throw new ArgumentOutOfRangeException(nameof(d), d, "unknown direction"),
    };

    // For bool the compiler CAN prove exhaustiveness -- no fallback needed.
    public static string YesNo(bool b) => b switch
    {
        true => "yes",
        false => "no",
    };
}

// The compiler knows Success and Failure are the only possibilities.
public closed record Result;
public sealed record Success(string Payload) : Result;
public sealed record Failure(string Reason) : Result;

public static class ClosedSwitch
{
    // No `_` arm, and no CS8509 warning: the hierarchy is closed.
    public static string Render(Result result) => result switch
    {
        Success(var payload) => $"ok: {payload}",
        Failure(var reason) => $"failed: {reason}",
    };
}

// A union of two existing, unrelated types.
public union Payment(CardPayment, BankTransfer);

public sealed record CardPayment(string Last4, decimal Amount);
public sealed record BankTransfer(string Iban, decimal Amount);

public static class UnionSwitch
{
    public static decimal AmountOf(Payment payment) => payment switch
    {
        CardPayment card => card.Amount,
        BankTransfer transfer => transfer.Amount,
    };
}

public abstract record Shape
{
    private Shape() { }                              // only nested types can derive

    public sealed record Circle(double Radius) : Shape;
    public sealed record Rectangle(double Width, double Height) : Shape;
}

public static class ApproximatedClosedHierarchy
{
    public static double Area(Shape shape) => shape switch
    {
        Shape.Circle c => Math.PI * c.Radius * c.Radius,
        Shape.Rectangle r => r.Width * r.Height,
        _ => throw new ArgumentOutOfRangeException(nameof(shape)),
    };
}

public abstract class Vehicle;
public sealed class Car : Vehicle
{
    public int Passengers { get; init; }
}

public sealed class Taxi : Vehicle
{
    public int Fares { get; init; }
}

public sealed class Bus : Vehicle
{
    public int Capacity { get; init; }
    public int Riders { get; init; }
}

public sealed class DeliveryTruck : Vehicle
{
    public int GrossWeightClass { get; init; }
}

public static class TollCalculator
{
    public static decimal BaseToll(Vehicle vehicle) => vehicle switch
    {
        Car { Passengers: 0 } => 2.00m + 0.50m,
        Car { Passengers: 1 } => 2.00m,
        Car { Passengers: 2 } => 2.00m - 0.50m,
        Car => 2.00m - 1.00m,

        Taxi { Fares: 0 } => 3.50m + 1.00m,
        Taxi { Fares: 1 } => 3.50m,
        Taxi => 3.50m - 1.00m,

        Bus b when (double)b.Riders / b.Capacity < 0.50 => 5.00m + 2.00m,
        Bus b when (double)b.Riders / b.Capacity > 0.90 => 5.00m - 1.00m,
        Bus => 5.00m,

        DeliveryTruck { GrossWeightClass: > 5000 } => 10.00m + 5.00m,
        DeliveryTruck { GrossWeightClass: < 3000 } => 10.00m - 2.00m,
        DeliveryTruck => 10.00m,

        null => throw new ArgumentNullException(nameof(vehicle)),
        _ => throw new ArgumentException("unknown vehicle type", nameof(vehicle)),
    };

    // Peak-hour multipliers are a tuple switch over independent inputs.
    public static decimal PeakMultiplier(DayOfWeek day, int hour, bool inbound) =>
        (day, hour, inbound) switch
        {
            (DayOfWeek.Saturday or DayOfWeek.Sunday, _, _) => 1.0m,
            (_, >= 6 and < 10, true) => 2.0m,
            (_, >= 16 and < 20, false) => 2.0m,
            (_, >= 10 and < 16, _) => 1.5m,
            _ => 1.0m,
        };
}