Records and pattern matching in C# 14

What are records?

Records are reference types (or value types) designed to model immutable data. Unlike classes, records have:

• Value equality — two records with the same values are equal
• Automatic deconstruction
• A descriptive ToString() generated automatically
• with expression to clone with changes

// Class: equality by reference
class PersonClass { public string Name { get; set; } = ""; }
var c1 = new PersonClass { Name = "David" };
var c2 = new PersonClass { Name = "David" };
Console.WriteLine(c1 == c2); // false — different references

// Record: equality by value
record PersonRecord(string Name, int Age);
var r1 = new PersonRecord("David", 30);
var r2 = new PersonRecord("David", 30);
Console.WriteLine(r1 == r2); // true — same values

Positional records

The most concise form. Primary constructor parameters become init-only properties:

// Positional syntax
record Coordinate(double Latitude, double Longitude);

var nyc = new Coordinate(40.71, -74.01);
Console.WriteLine(nyc); // Coordinate { Latitude = 40.71, Longitude = -74.01 }

// Deconstruction
var (lat, lon) = nyc;
Console.WriteLine($"Lat: {lat}, Lon: {lon}");

// LINQ with records
var cities = new List<Coordinate>
{
    new(40.71, -74.01),
    new(51.51, -0.13),
    new(-33.87, 151.21),
};

var northernHemisphere = cities.Where(c => c.Latitude > 0);

with expression

Creates a copy of the record with modified properties:

record Order(int Id, string Customer, decimal Total, string Status);

var order = new Order(1, "David", 299.99m, "pending");

// Change status without mutating the original
var approved = order with { Status = "approved" };
var cancelled = order with { Status = "cancelled", Total = 0m };

Console.WriteLine(order.Status);    // pending — unchanged
Console.WriteLine(approved.Status); // approved

// Useful in transformation chains
var finalOrder = order
    with { Status = "processing" }
    with { Total = order.Total * 0.9m }; // 10% discount

record struct

For small types copied frequently, record struct is more efficient as it lives on the stack:

// record struct — value semantics (copies, does not share reference)
record struct Color(byte R, byte G, byte B, byte A = 255)
{
    public static readonly Color Red   = new(255, 0, 0);
    public static readonly Color Green = new(0, 255, 0);
    public static readonly Color Blue  = new(0, 0, 255);
    public static readonly Color White = new(255, 255, 255);

    // Instance method
    public Color Blend(Color other) =>
        new((byte)((R + other.R) / 2),
            (byte)((G + other.G) / 2),
            (byte)((B + other.B) / 2));

    public string ToHex() => $"#{R:X2}{G:X2}{B:X2}";
}

var purple = Color.Red.Blend(Color.Blue);
Console.WriteLine(purple.ToHex()); // #7F007F

Pattern Matching

Pattern matching lets you check the shape of a value and extract information declaratively.

is expression

object obj = "Hello .NET";

// Type pattern
if (obj is string s)
    Console.WriteLine($"It's a string with {s.Length} characters");

// Null check
if (obj is not null)
    Console.WriteLine("Not null");

// Constant pattern
if (obj is "Hello .NET")
    Console.WriteLine("Exact match");

Advanced switch expression

// Property patterns
record Employee(string Name, string Role, decimal Salary, bool Active);

static decimal CalculateBonus(Employee emp) => emp switch
{
    { Active: false }                           => 0,
    { Role: "CEO" }                             => emp.Salary * 0.5m,
    { Role: "Manager", Salary: > 5000 }         => emp.Salary * 0.2m,
    { Role: "Developer", Salary: > 3000 }       => emp.Salary * 0.15m,
    { Active: true }                            => emp.Salary * 0.05m,
    _                                           => 0
};

var dev = new Employee("David", "Developer", 4000m, true);
Console.WriteLine($"Bonus: ${CalculateBonus(dev):F2}"); // $600.00

Relational and logical patterns

// Relational: <, >, <=, >=
static string ClassifyBMI(double bmi) => bmi switch
{
    < 18.5              => "Underweight",
    >= 18.5 and < 25.0  => "Normal",
    >= 25.0 and < 30.0  => "Overweight",
    >= 30.0             => "Obese"
};

// Logical: and, or, not
static bool IsBusinessHour(int hour) =>
    hour is (>= 8 and <= 12) or (>= 14 and <= 18);

static bool IsWeekday(DayOfWeek day) =>
    day is not (DayOfWeek.Saturday or DayOfWeek.Sunday);

List patterns (C# 11+)

// Match lists by structure
static string AnalyzeSequence(int[] seq) => seq switch
{
    []                           => "empty",
    [0]                          => "only zero",
    [_, 0, _]                    => "zero in the middle",
    [> 0, > 0, > 0]              => "all positive (3 elements)",
    [var a, var b] when a == b   => $"two equal values: {a}",
    [var h, .. var rest]         => $"starts with {h}, {rest.Length} more"
};

Console.WriteLine(AnalyzeSequence(new[] { 5, 3, 8, 1 }));
// "starts with 5, 3 more"

Deconstruct in patterns

record Point(double X, double Y);

static string LocatePoint(Point p) => p switch
{
    (0, 0)                => "Origin",
    (> 0, > 0)            => "Quadrant I",
    (< 0, > 0)            => "Quadrant II",
    (< 0, < 0)            => "Quadrant III",
    (> 0, < 0)            => "Quadrant IV",
    (_, 0) or (0, _)      => "On an axis"
};

var p = new Point(3, -1);
Console.WriteLine(LocatePoint(p)); // Quadrant IV

Practice

1. Domain records: Create record Invoice(int Id, string Customer, List<InvoiceLine> Items) and record InvoiceLine(string Product, decimal Price, int Quantity). Use with to mark an invoice as "paid".
2. Shape pattern matching: Implement DescribeShape(object shape) that uses a switch expression with type patterns for Circle, Rectangle, and Triangle.
3. List patterns: Write a method that analyzes the first 3 elements of a price list and returns "Uptrend", "Downtrend", or "Stable".

In the next lesson we will start with ASP.NET Core 10: how to build web APIs with Minimal APIs and the middleware pipeline.