Records (C# 9+) are a concise way to define types that are primarily immutable data carriers with value-based equality. They auto-generate boilerplate (constructor, equality, ToString, etc.), making them ideal for DTOs, domain values, and data modeling.
;
p1 = Person(, );
p1.Name;
Console.WriteLine(p1);
The positional syntax record Person(string Name, int Age) generates everything — properties, constructor, ToString, equality, deconstruction — eliminating the boilerplate a regular class would need.
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b; // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
Unlike classes (which compare by reference identity), records compare by value — two records with the same property values are equal. This is exactly what you want for data objects.
public record Person(string Name, int Age); // properties are init-only (immutable)
var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 }; // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
Records are immutable by default, and the with expression creates a modified copy (non-destructive mutation) — ideal for working with immutable data.
public record class Ref(int X); // a reference type (default) with value equality
public record struct Val(int X); // a VALUE type record (C# 10)
Records are an important modern C# feature (C# 9+) that makes defining immutable data types concise and correct, so understanding them is valuable for modern C# development.
Their key benefits address real needs: they eliminate boilerplate (auto-generating constructors, properties, ToString, equality, and deconstruction from a one-line declaration — versus the substantial code a regular class requires), and they provide value-based equality (two records with equal properties are equal, unlike classes which compare by reference) — which is exactly the behavior you want for data objects, DTOs, and domain values, and which classes get wrong by default.
Records are also immutable by default with the elegant with expression for non-destructive mutation (creating modified copies), supporting the immutable, functional style that's increasingly favored for safer, more predictable code.
Understanding records — the concise syntax, value equality, immutability with with, and record structs — is valuable for writing clean modern C#, since they're the idiomatic way to model data (DTOs, API models, value objects, immutable state) and are widely used in current codebases.
Knowing when to use a record (immutable data with value semantics) versus a class (mutable objects with identity and rich behavior) reflects fluency with modern C#.
Since records dramatically simplify data modeling while providing correct equality and immutability — common needs that were tedious and error-prone before — they're an important, frequently-used feature that's a hallmark of modern, clean C# code.