Modern C#: Records, Structs, Pattern Matching and Extension Methods

Interviewers increasingly ask about features added in recent versions of C#. This article covers the ones that come up most: records, structs, init and required, pattern matching, and extension methods.

Records

A record is a type designed for data. The compiler generates value-based equality, a readable ToString(), and support for non-destructive copies with with.

var a = new Person("Asha", 31);
var b = new Person("Asha", 31);

Console.WriteLine(a == b);                  // True   (equal by value)
Console.WriteLine(ReferenceEquals(a, b));   // False  (still two objects)

var older = a with { Age = 32 };            // a copy with one property changed
Console.WriteLine(older);                   // Person { Name = Asha, Age = 32 }
Console.WriteLine(a);                       // Person { Name = Asha, Age = 31 }

public record Person(string Name, int Age);

Struct or class?

A struct is a value type, copied on assignment. Choose a struct only when the type is:

• small (as a rule of thumb, 16 bytes or less),
• logically a single value (a coordinate, a money amount, a date),
• immutable, and
• short-lived or stored in large arrays.

Otherwise use a class. Large or mutable structs cause surprising copies. A struct cannot inherit from another type, but it can implement interfaces. Mark it readonly struct to guarantee it never changes.

init-only and required properties

init allows a property to be set only while the object is being created. required (C# 11) forces callers to set it:

var product = new Product { Name = "Keyboard", Price = 25m };
Console.WriteLine($"{product.Name}: {product.Price}");    // Keyboard: 25

// product.Name = "Mouse";            // compile error: init-only property
// new Product { Price = 1m };        // compile error: required member 'Name' must be set

public class Product
{
    public required string Name { get; init; }
    public decimal Price { get; init; }
}

This gives you immutable objects with readable object-initializer syntax and compile-time protection against half-built objects.

Pattern matching

Pattern matching tests the shape of a value and extracts parts of it in one step.

Console.WriteLine(Classify(15));                    // Teenager
Console.WriteLine(Describe(42));                    // integer 42
Console.WriteLine(Describe("hi"));                  // text of length 2
Console.WriteLine(Describe(null));                  // nothing

object value = 42;
if (value is int n and > 40)
    Console.WriteLine($"big int {n}");              // big int 42

static string Classify(int age) => age switch
{
    < 0 => "Invalid",
    < 13 => "Child",
    < 20 => "Teenager",
    _ => "Adult"
};

static string Describe(object? item) => item switch
{
    null => "nothing",
    int number => $"integer {number}",
    string text => $"text of length {text.Length}",
    _ => "something else"
};

The common patterns: type (int number), relational (< 13), logical (and, or, not), property ({ Age: > 18 }), and list patterns ([1, 2, ..]). A switch expression must be exhaustive, so the compiler warns about a missing case.

Extension methods

An extension method adds a method to an existing type without changing it or inheriting from it. It is a static method in a static class whose first parameter has the this modifier:

Console.WriteLine("Hello, world".Truncate(5));      // Hello
Console.WriteLine("Hi".Truncate(5));                // Hi

public static class StringExtensions
{
    public static string Truncate(this string value, int maxLength) =>
        value.Length <= maxLength ? value : value[..maxLength];
}

LINQ is built from extension methods on IEnumerable<T>. Remember that an extension method is only syntax: it compiles to an ordinary static call, so it cannot access private members, and an instance method with the same name always wins.

Practise

1. Turn a class with three properties into a record and compare two instances with .
2. Write a switch expression that maps a to "Weekday" or "Weekend".
3. Write an extension method and use it.