C# Pattern Matching — Why var Patterns Let Null Through

using System;

// A sealed hierarchy: the compiler knows EVERY possible subtype at compile time.
// This enables exhaustiveness checking — miss a case and you get CS8509.
abstract record PaymentMethod;
record CreditCard(string Network, decimal Limit) : PaymentMethod;
record BankTransfer(string Iban, bool IsSameBank) : PaymentMethod;
record DigitalWallet(string Provider, bool IsVerified) : PaymentMethod;

class PatternMatchingInternals
{
    static void Main()
    {
        PaymentMethod[] payments =
        [
            new CreditCard("Visa", 5000m),
            new BankTransfer("GB29NWBK60161331926819", IsSameBank: true),
            new DigitalWallet("PayPal", IsVerified: false),
            new CreditCard("Amex", 15000m)
        ];

        foreach (var payment in payments)
        {
            // switch EXPRESSION (not statement) — returns a value.
            // The compiler builds a decision tree: one isinst per type,
            // not one isinst per arm. Cheaper on large hierarchies.
            string processingRoute = payment switch
            {
                // Type pattern + property pattern combined.
                // "CreditCard card" binds the cast result to 'card' — no manual cast needed.
                CreditCard card when card.Limit >= 10_000m
                    => $"[HIGH-VALUE] Route {card.Network} to premium processor",

                // Property pattern: tests members WITHOUT needing a variable binding.
                CreditCard { Network: "Amex" }
                    => "[AMEX] Route to specialist Amex gateway",

                // Remaining CreditCard cases (order matters — more specific arms first).
                CreditCard card
                    => $"[STANDARD] Route {card.Network} via standard processor",

                // Logical pattern: 'and' combines two sub-patterns.
                // Both must match for the arm to fire.
                BankTransfer { IsSameBank: true } and BankTransfer transfer
                    => $"[INTERNAL] Fast-track IBAN {transfer.Iban[..4]}****",

                BankTransfer transfer
                    => $"[EXTERNAL] SWIFT route for {transfer.Iban[..2]} bank",

                // Relational pattern is not valid on reference types alone —
                // use property pattern + when guard instead.
                DigitalWallet { IsVerified: false }
                    => "[BLOCKED] Wallet not verified — request verification first",

                DigitalWallet { Provider: var provider }
                    => $"[WALLET] Route to {provider} settlement API",

                // The compiler enforces exhaustiveness because PaymentMethod is abstract.
                // Remove any arm above and CS8509 fires. No _ discard needed here.
                // (We add it defensively in non-sealed hierarchies — see Gotchas.)
            };

            Console.WriteLine(processingRoute);
        }
    }
}

using System;
using System.Collections.Generic;

// A record with a positional constructor automatically generates Deconstruct(),
// which is what the positional pattern calls under the hood.
record TransactionEvent(string EventType, decimal Amount, string Currency);

// Simulates a raw message frame arriving from a payment broker.
// Format: [version, command, ...payload]
static class MessageParser
{
    // List pattern matching on a ReadOnlySpan<byte> is allocation-free.
    // The compiler emits Length checks and index accesses — no LINQ.
    public static string ParseBrokerFrame(byte[] frame) => frame switch
    {
        // Exact match: version=1, command=0x01 (PING), nothing else.
        [0x01, 0x01]                          => "Heartbeat ping — no payload",

        // Slice pattern: version=1, command=0x02, THEN anything (captured as 'payload').
        [0x01, 0x02, .. var payload]          => $"Auth handshake — {payload.Length} byte payload",

        // Version 2 protocol: first byte=0x02, last byte must be 0xFF (checksum marker).
        // The '..' in the middle discards the bytes we don't care about here.
        [0x02, .., 0xFF]                      => "V2 frame with valid checksum marker",

        // Empty frame: should never happen in production — log and discard.
        []                                    => "Empty frame — possible broker bug",

        // Any other pattern: unknown or malformed.
        _                                     => $"Unknown frame: version={frame[0]:X2}"
    };

    // Positional pattern on a record: deconstructs into (EventType, Amount, Currency)
    // without you writing a single property access.
    public static string ClassifyEvent(TransactionEvent evt) => evt switch
    {
        // Nested relational pattern inside a positional pattern.
        // Reads: EventType is "CHARGE", Amount > 1000, Currency is "USD".
        ("CHARGE", > 1000m, "USD")   => "High-value USD charge — trigger fraud review",

        // Discard '_' for positions we don't care about.
        ("REFUND", _, "GBP")         => "GBP refund — post to UK ledger",

        // 'var' binding captures the value without constraining it.
        ("CHARGE", var amount, var currency)
                                     => $"Standard charge: {amount} {currency}",

        // Logical 'or' pattern — matches either event type.
        ("VOID" or "CANCEL", _, _)   => "Transaction voided — release reserved funds",

        _                            => $"Unclassified event: {evt.EventType}"
    };
}

class PositionalAndListPatterns
{
    static void Main()
    {
        // --- List / Slice patterns ---
        Console.WriteLine("=== Broker Frame Parsing ===");
        Console.WriteLine(MessageParser.ParseBrokerFrame([0x01, 0x01]));
        Console.WriteLine(MessageParser.ParseBrokerFrame([0x01, 0x02, 0xAB, 0xCD, 0xEF]));
        Console.WriteLine(MessageParser.ParseBrokerFrame([0x02, 0xAA, 0xBB, 0xFF]));
        Console.WriteLine(MessageParser.ParseBrokerFrame([]));
        Console.WriteLine(MessageParser.ParseBrokerFrame([0x03, 0x99]));

        // --- Positional patterns ---
        Console.WriteLine("\n=== Transaction Event Classification ===");
        Console.WriteLine(MessageParser.ClassifyEvent(new("CHARGE", 2500m, "USD")));
        Console.WriteLine(MessageParser.ClassifyEvent(new("REFUND", 45m, "GBP")));
        Console.WriteLine(MessageParser.ClassifyEvent(new("CHARGE", 99m, "EUR")));
        Console.WriteLine(MessageParser.ClassifyEvent(new("VOID", 150m, "USD")));
        Console.WriteLine(MessageParser.ClassifyEvent(new("DISPUTE", 300m, "CAD")));
    }
}

using System;

#nullable enable   // Ensure NRT analysis is active

record RiskScore(int Score, string? Reason);

class RiskEngine
{
    // Simulates an external fraud signal that might not always be available.
    static bool IsKnownFraudDevice(string deviceId) =>
        deviceId is "DEVICE-BLACKLISTED-001" or "DEVICE-BLACKLISTED-002";

    public static string Evaluate(RiskScore? score, string deviceId)
    {
        return score switch
        {
            // null pattern — handles the case where no score was produced at all.
            // After this arm, every other arm knows 'score' is non-null.
            null
                => "No risk score available — default to manual review",

            // Type + property + when guard.
            // The when guard calls an external method — pure patterns can't do this.
            // Note: 'score' here is already known non-null by the compiler (NRT flow).
            { Score: >= 80 } when IsKnownFraudDevice(deviceId)
                => $"BLOCK — high score AND known fraud device [{deviceId}]",

            // Relational patterns on the Score property.
            { Score: >= 80 }
                => $"HIGH RISK ({score.Score}) — automatic decline",

            // Property pattern matching a nullable string property.
            // 'not null' pattern on Reason: only matches when Reason has a value.
            { Score: >= 50, Reason: not null and var reason }
                => $"MEDIUM RISK ({score.Score}) — reason: {reason}",

            { Score: >= 50 }
                => $"MEDIUM RISK ({score.Score}) — no reason provided",

            // var pattern: catches EVERYTHING including theoretically impossible
            // negative scores. Useful as a documented catch-all, not a lazy escape hatch.
            var fallthrough
                => $"LOW RISK ({fallthrough.Score}) — approve with monitoring"
        };
        // Notice: no discard '_' arm needed because 'var' covers everything.
        // If we used '_' instead of 'var fallthrough', we'd lose access to the value.
    }
}

class WhenGuardsAndNullEdgeCases
{
    static void Main()
    {
        var scenarios = new (RiskScore? Score, string Device)[]
        {
            (null,                          "DEVICE-NORMAL-123"),
            (new(92, null),                 "DEVICE-BLACKLISTED-001"),
            (new(88, "Velocity spike"),      "DEVICE-NORMAL-456"),
            (new(65, "New account"),         "DEVICE-NORMAL-789"),
            (new(55, null),                 "DEVICE-NORMAL-321"),
            (new(20, "Trusted customer"),    "DEVICE-NORMAL-000")
        };

        Console.WriteLine("=== Risk Evaluation Results ===");
        foreach (var (score, device) in scenarios)
        {
            Console.WriteLine(RiskEngine.Evaluate(score, device));
        }

        // Demonstrates the TYPE PATTERN vs VAR PATTERN null difference.
        Console.WriteLine("\n=== Null Matching Gotcha Demo ===");
        object? maybeNull = null;

        // Type pattern: 'string s' does NOT match null. Falls to the next arm.
        string typePatternResult = maybeNull switch
        {
            string s => $"Got string: {s}",          // skipped — null doesn't match
            null     => "Matched null explicitly",   // fires
            _        => "Something else"
        };
        Console.WriteLine($"Type pattern result: {typePatternResult}");

        // Var pattern: 'var v' DOES match null. Fires immediately.
        string varPatternResult = maybeNull switch
        {
            var v when v is string s => $"Got string: {s}",
            var v                   => $"var matched — value is: {v ?? "(null)"}"
        };
        Console.WriteLine($"Var pattern result:  {varPatternResult}");
    }
}

using System;
using System.Diagnostics;

// ── Active Pattern Idiom ──────────────────────────────────────────────────────
// We want to route a payment by its processing window (time of day + day type).
// The logic is complex, but we expose it as a deconstructable type so the
// call site reads like a clean pattern match.

enum DayType { Weekday, Weekend, Holiday }

readonly struct ProcessingWindow
{
    public DayType DayType { get; }
    public int Hour { get; }            // 0-23
    public bool IsRealTimeEligible { get; }

    public ProcessingWindow(DateTime when, bool realTimeEnabled)
    {
        // Complex business logic hidden here, not at the call site.
        DayType = when.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday
            ? DayType.Weekend : DayType.Weekday;
        Hour = when.Hour;
        IsRealTimeEligible = realTimeEnabled && DayType == DayType.Weekday;
    }

    // Deconstruct makes this usable in positional patterns.
    public void Deconstruct(out DayType day, out int hour, out bool realTime)
        => (day, hour, realTime) = (DayType, Hour, IsRealTimeEligible);
}

static class PaymentRouter
{
    public static string Route(decimal amount, DateTime when, bool realTimeEnabled)
    {
        // The 'active pattern': construct the window, then immediately match on it.
        // The call site is clean — no if-else tower, no DateTime arithmetic visible.
        return new ProcessingWindow(when, realTimeEnabled) switch
        {
            // Real-time, business hours, large amount — premium fast lane.
            (DayType.Weekday, >= 9 and <= 17, true) when amount >= 10_000m
                => "[RTGS] Real-time gross settlement — premium lane",

            // Real-time eligible, any business hours.
            (DayType.Weekday, >= 9 and <= 17, true)
                => "[RT] Real-time payment network",

            // Overnight batch window.
            (DayType.Weekday, < 9 or > 17, _)
                => "[BATCH] Queue for overnight batch processing",

            // Weekends: only batch available regardless of real-time flag.
            (DayType.Weekend, _, _)
                => "[WEEKEND-BATCH] Weekend settlement batch",

            // Should never hit — but var catches any unexpected DayType enum expansion.
            var unexpected
                => $"[FALLBACK] Unhandled window: {unexpected}"
        };
    }
}

// ── Performance: Pattern Matching vs If-Else ──────────────────────────────────
// Demonstrates that for type dispatch, switch expressions are faster.
// Real benchmark — not a micro-benchmark claim.

abstract record Shape;
record Circle(double Radius) : Shape;
record Rectangle(double Width, double Height) : Shape;
record Triangle(double Base, double Height) : Shape;

static class AreaCalculator
{
    // Pattern matching: compiler builds a decision tree with shared isinst.
    public static double WithPatternMatching(Shape shape) => shape switch
    {
        Circle c       => Math.PI * c.Radius * c.Radius,
        Rectangle r    => r.Width * r.Height,
        Triangle t     => 0.5 * t.Base * t.Height,
        _              => throw new ArgumentException($"Unknown shape: {shape.GetType().Name}")
    };

    // If-else chain: three separate isinst + cast pairs — more IL, same JIT output
    // on small hierarchies, measurably slower on larger ones.
    public static double WithIfElse(Shape shape)
    {
        if (shape is Circle c)    return Math.PI * c.Radius * c.Radius;
        if (shape is Rectangle r) return r.Width * r.Height;
        if (shape is Triangle t)  return 0.5 * t.Base * t.Height;
        throw new ArgumentException($"Unknown shape: {shape.GetType().Name}");
    }
}

class ProductionPatternTechniques
{
    static void Main()
    {
        // Active pattern routing demo.
        Console.WriteLine("=== Payment Routing via Active Pattern ===");
        var testCases = new (decimal Amount, DateTime When, bool RT)[]
        {
            (15_000m, new DateTime(2024, 6, 17, 14, 0, 0), true),   // Weekday PM, RT, high value
            (500m,    new DateTime(2024, 6, 17, 11, 0, 0), true),   // Weekday AM, RT, low value
            (500m,    new DateTime(2024, 6, 17, 22, 0, 0), false),  // Weekday night, no RT
            (200m,    new DateTime(2024, 6, 15, 10, 0, 0), true),   // Saturday
        };
        foreach (var (amount, when, rt) in testCases)
            Console.WriteLine($"{when:ddd HH:mm} | {amount,8:C} | {PaymentRouter.Route(amount, when, rt)}");

        // Performance comparison (illustrative — run BenchmarkDotNet in production).
        Console.WriteLine("\n=== Area Calculation Performance ===");
        Shape[] shapes = [new Circle(5), new Rectangle(3, 4), new Triangle(6, 8)];
        const int iterations = 1_000_000;

        var sw = Stopwatch.StartNew();
        double total1 = 0;
        for (int i = 0; i < iterations; i++)
            foreach (var s in shapes) total1 += AreaCalculator.WithPatternMatching(s);
        sw.Stop();
        Console.WriteLine($"Pattern matching: {sw.ElapsedMilliseconds}ms (sum={total1:F0})");

        sw.Restart();
        double total2 = 0;
        for (int i = 0; i < iterations; i++)
            foreach (var s in shapes) total2 += AreaCalculator.WithIfElse(s);
        sw.Stop();
        Console.WriteLine($"If-else chain:    {sw.ElapsedMilliseconds}ms (sum={total2:F0})");
        Console.WriteLine("(Difference grows significantly with larger, sealed hierarchies.)");
    }
}

using System;
using System.Buffers;

// Simulates a WebSocket frame parsing using list patterns on Span<byte>
// Frame format: [opcode (1 byte), length (1-2 bytes), payload (variable)]

static class WebSocketParser
{
    // Pass ReadOnlySpan<byte> — no allocations.
    public static string ParseFrame(ReadOnlySpan<byte> frame) => frame switch
    {
        // Opcode 0x09 = Ping, no payload
        [0x09, 0x00] => "Ping frame (no payload)",

        // Opcode 0x0A = Pong, payload length up to 125
        [0x0A, <= 125, .. var pongPayload] => $"Pong frame: payload of {pongPayload.Length} bytes",

        // Opcode 0x01 = Text, small payload (masking bit not set for simplicity)
        [0x01, var len, .. var textPayload] when len <= 125
            => $"Text frame: length={len}, first 10 bytes: {BitConverter.ToString(textPayload[..Math.Min(10, textPayload.Length)])}",

        // Extended length: first byte indicates length is encoded in next 2 bytes (126)
        // Pattern: opcode=0x01, length marker=126, then 2-byte length, then payload
        [0x01, 0x7E, .. var extended, .. var payload]
            when extended.Length == 2
            => $"Text frame (extended): total length={(extended[0] << 8) | extended[1]}, actual payload={payload.Length}",

        // Binary frame (opcode 0x02)
        [0x02, ..] => "Binary frame — route to decoding pipeline",

        // Connection close (opcode 0x08)
        [0x08, ..] => "Close frame — initiate graceful shutdown",

        // Unknown or malformed
        _ when frame.Length == 0 => "Empty frame — probable connection reset",
        _ => $"Unknown frame: opcode=0x{frame[0]:X2}, length={frame.Length}"
    };
}

class SpanPatternMatching
{
    static void Main()
    {
        // Test frames as byte arrays (implicit conversion to ReadOnlySpan<byte>)
        byte[] pingFrame = [0x09, 0x00];
        byte[] pongFrame = [0x0A, 0x03, 0xAB, 0xCD, 0xEF];
        byte[] textFrame = [0x01, 0x0A, 0x48, 0x65, 0x6C, 0x6C, 0x6F]; // "Hello"
        byte[] extendedTextFrame = [0x01, 0x7E, 0x01, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F];
        byte[] binaryFrame = [0x02, 0x04, 0x00, 0x00, 0x00, 0x01];
        byte[] closeFrame = [0x08, 0x00];

        Console.WriteLine(WebSocketParser.ParseFrame(pingFrame));
        Console.WriteLine(WebSocketParser.ParseFrame(pongFrame));
        Console.WriteLine(WebSocketParser.ParseFrame(textFrame));
        Console.WriteLine(WebSocketParser.ParseFrame(extendedTextFrame));
        Console.WriteLine(WebSocketParser.ParseFrame(binaryFrame));
        Console.WriteLine(WebSocketParser.ParseFrame(closeFrame));
        Console.WriteLine(WebSocketParser.ParseFrame([]));
    }
}