Records and pattern matching

Why records?

Much of a business app is data moving around: an order request, a search result, a message on a queue. For such data you want: easy creation, no accidental changes, and "same data means equal". Writing that by hand in a class is long. A record (C# 9) gives it in one line.

var a = new Product("Pen", 10m);
var b = new Product("Pen", 10m);
Console.WriteLine(a);          // Product { Name = Pen, Price = 10 }
Console.WriteLine(a == b);     // True: same data
Console.WriteLine(a.Name);     // Pen
// a.Price = 12m;              // error: init-only property

public record Product(string Name, decimal Price);

Value equality versus reference equality

For normal classes, == asks "is this the same object?" (reference equality). For records, == asks "do they hold the same data?" (value equality). Two different record objects with equal properties are equal. This is exactly what you want for data, and it makes tests easier to write.

with-expressions: copy with changes

var pen = new Product("Pen", 10m);
var costlier = pen with { Price = 12m };
Console.WriteLine(pen.Price);       // 10 (unchanged)
Console.WriteLine(costlier.Price);  // 12

Deconstruction

var (name, price) = new Product("Notebook", 45m);
Console.WriteLine($"{name} costs {price}");

record class and record struct

Records can also have normal bodies with extra methods and properties, and can inherit from other records. Entities whose data changes over time and which have an identity, like a database row being edited, are usually better as classes.

Pattern matching

A pattern is a test of a value's shape. You have used some already: the relational patterns >= 90 in switch expressions. C# supports many kinds, and you can combine them.

Console.WriteLine(Concession(new Passenger("Kamala", 66, false)));   // 0.4

static decimal Concession(Passenger p) => p switch
{
    { IsDisabled: true } => 0.75m,
    { Age: < 5 } => 1.0m,
    { Age: >= 60 } => 0.4m,
    _ => 0m
};

public record Passenger(string Name, int Age, bool IsDisabled);

object input = 42;
string result = input switch
{
    int n when n < 0 => "negative number",
    int n => $"number {n}",
    string s => $"text of length {s.Length}",
    null => "nothing",
    _ => "something else"
};
Console.WriteLine(result);    // number 42

int[] digits = { 1, 5, 9 };
Console.WriteLine(digits is [1, .., 9]);   // True

Common mistakes and fixes

• Expecting records to be fully immutable: a record holding a List<T> still lets someone change the list's items. Use read-only collections for deep immutability.
• Putting a broad arm before a specific one: { Age: >= 5 } before { Age: >= 60 } means seniors never reach their arm. The compiler often warns when an arm can never match.
• Forgetting the _ arm: a non-exhaustive switch expression throws at run time for unmatched values.
• Using record struct when you wanted immutability: positional record struct properties are writable; add readonly.