Introduced in C# 9.0, record types offer a concise way to create immutable data models with value-based equality. They simplify many common programming tasks when working with data-centric classes.
What Are Record Types?
Records are reference types (like classes) but with built-in functionality for representing immutable data:
// Traditional class approach
public class PersonClass
{
public string FirstName { get; init; }
public string LastName { get; init; }
// Requires manual implementation of equality, hash code, etc.
}
// Equivalent record
public record Person(string FirstName, string LastName);
This simple declaration creates an immutable type with:
Constructor that accepts all properties
Public, init-only properties
Value-based equality (compares property values, not references)
ToString() implementation that displays all properties
Deconstruction support
Benefits of Using Records
1. Immutability by Default
Records are designed for immutability, making them perfect for:
Domain models
DTOs (Data Transfer Objects)
API responses
Configuration objects
var person = new Person("John", "Doe");
// person.FirstName = "Jane"; // Compile error - properties are init-only
2. Non-Destructive Mutation with 'with' Expressions
Need to change a property? Use the 'with' expression:
var person = new Person("John", "Doe");
var updatedPerson = person with { FirstName = "Jane" };
// person still refers to "John Doe"
// updatedPerson refers to "Jane Doe"
3. Value-Based Equality
Records automatically implement value equality:
var person1 = new Person("John", "Doe");
var person2 = new Person("John", "Doe");
Console.WriteLine(person1 == person2); // True
Console.WriteLine(person1.Equals(person2)); // True
4. Easy Class Hierarchies
Records can inherit from other records:
public record Person(string FirstName, string LastName);
public record Employee(string FirstName, string LastName, string Department)
: Person(FirstName, LastName);
When to Use Records
Use records when:
You need immutable objects
Equality should compare values, not references
You're creating simple data containers
You need non-destructive updates with the 'with' expression
Use traditional classes when:
You need mutable properties
You need reference-based equality
You need more control over property implementation
While records are convenient, be aware that:
The 'with' expression creates a new object (memory allocation)
Comparing large records can be slower than reference equality
Example: API Data Model
// API response model
public record WeatherForecast(
DateTime Date,
int TemperatureC,
string Summary)
{
public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}
// Usage
var forecasts = await httpClient.GetFromJsonAsync<List<WeatherForecast>>("weatherforecast");
Records are a powerful addition to C#, making it easier to create robust data models with less boilerplate code.
// Walt's dev notes
See what I'm building next.
New projects, stories from building them, and my take on what's happening in dev.
Keep me posted →
Walt · ThatSoftwareDude
Walt is a software engineer, startup founder and previous mentor for a coding bootcamp. He has been creating software for the past 20+ years.