Record structs in C Sharp (C#) - Deep Dive

Overview - Record structs

What is it?

Record structs are a special kind of value type in C# that combine the benefits of structs with the concise syntax and features of records. They allow you to create small, immutable data containers with built-in value equality and easy-to-use syntax. Unlike classes, record structs are stored on the stack, making them more efficient for small data. They help you write clear and safe code when you want lightweight data objects.

Why it matters

Without record structs, developers often had to choose between mutable structs with manual equality or verbose code for immutable data. Record structs solve this by providing a simple way to create immutable, value-based data types that perform well. This improves code safety, reduces bugs from accidental changes, and boosts performance in scenarios like graphics, games, or data processing where many small data objects are used.

Where it fits

Before learning record structs, you should understand basic structs and classes in C#, and the concept of records introduced in C# 9. After mastering record structs, you can explore advanced immutability patterns, performance optimization with value types, and how to use records and record structs together in complex applications.

Mental Model

Core Idea

Record structs are lightweight, immutable value types with built-in value equality and concise syntax, combining the best of structs and records.

Think of it like...

Imagine a small, sturdy box that holds a fixed set of items and can be quickly copied or compared by checking the contents inside, not just the box itself.

┌───────────────────────────┐
│       Record Struct       │
├─────────────┬─────────────┤
│ Stored on   │ Stack       │
│ Immutability│ Yes         │
│ Equality    │ Value-based │
│ Syntax      │ Concise     │
└─────────────┴─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic structs

Concept: Learn what structs are and how they differ from classes in C#.

Structs are value types stored on the stack. They hold data directly and are copied by value. Unlike classes, structs do not support inheritance and are usually used for small data containers like points or colors. Example: struct Point { public int X; public int Y; }

Result

You can create and use small data containers that are efficient and copied by value.

Knowing structs are value types helps understand why record structs behave differently from classes and why they are efficient.

2

Foundation

Introduction to records

Concept: Understand what records are and how they provide value equality and immutability for reference types.

Records are reference types introduced in C# 9 that provide built-in value equality and concise syntax for immutable data. Example: record Person(string Name, int Age);

Result

You get objects that compare by their data, not by reference, making equality checks intuitive.

Seeing how records simplify immutable data helps prepare for record structs, which bring similar benefits to value types.

3

Intermediate

Defining record structs syntax

🤔Before reading on: do you think record structs use class-like or struct-like syntax? Commit to your answer.

Concept: Learn the syntax to declare a record struct and how it differs from regular structs and records.

Record structs are declared using the 'record struct' keywords. Example: public record struct Point(int X, int Y); This creates an immutable struct with value equality and concise syntax.

Result

You can quickly define small immutable data types with minimal code.

Understanding the syntax shows how C# blends struct efficiency with record features in one declaration.

4

Intermediate

Immutability and value equality in record structs

🤔Before reading on: do you think record structs allow changing their fields after creation? Commit to your answer.

Concept: Record structs are immutable by default and compare equal based on their data, not their memory address.

Fields in record structs are readonly by default, so you cannot change them after creation. Equality operators and methods are automatically generated to compare data. Example: var p1 = new Point(1, 2); var p2 = new Point(1, 2); Console.WriteLine(p1 == p2); // True

Result

You get safe, predictable data objects that compare by content, preventing bugs from accidental changes.

Knowing immutability and value equality are automatic helps avoid common errors with mutable structs.

5

Intermediate

Using record structs with methods and properties

Concept: Record structs can have methods, properties, and custom logic like regular structs.

You can add methods or properties to record structs to add behavior. Example: public record struct Point(int X, int Y) { public double Distance => Math.Sqrt(X*X + Y*Y); }

Result

Your record structs can do more than just hold data; they can compute values and encapsulate logic.

Understanding that record structs are full structs with extra features helps you design richer data types.

6

Advanced

Performance considerations of record structs

🤔Before reading on: do you think record structs always perform better than classes? Commit to your answer.

Concept: Record structs avoid heap allocation but can cause copying overhead if large or used improperly.

Because record structs are value types, they are stored on the stack or inline in arrays, which is fast. However, large record structs can be expensive to copy, so use them for small data. Avoid boxing or passing by value unnecessarily to keep performance benefits.

Result

You learn when record structs improve performance and when they might slow down your program.

Knowing the tradeoffs prevents misuse that can degrade performance despite the value type benefits.

7

Expert

Advanced features and limitations of record structs

🤔Before reading on: do you think record structs support inheritance like classes? Commit to your answer.

Concept: Record structs do not support inheritance but can implement interfaces and have custom equality logic.

Record structs cannot inherit from other structs or classes but can implement interfaces. You can override equality members if needed. They also support 'with' expressions for non-destructive mutation. Example: var p2 = p1 with { X = 5 };

Result

You can use record structs flexibly but must design around value type limitations.

Understanding these limits helps design correct and maintainable data types in complex systems.

Under the Hood

Record structs are compiled into value types with compiler-generated methods for equality, hashing, and cloning. The compiler creates readonly fields for the data, overrides Equals and GetHashCode to compare field values, and generates Deconstruct and 'with' methods for easy copying. Because they are structs, instances are stored on the stack or inline in arrays, avoiding heap allocation and garbage collection overhead.

Why designed this way?

Record structs were introduced to combine the performance benefits of structs with the expressive, safe syntax of records. Before, structs lacked built-in value equality and immutability support, leading to bugs and verbose code. The design balances efficiency with developer productivity, avoiding inheritance complexity by restricting record structs to value type semantics.

┌───────────────────────────────┐
│        Record Struct           │
├───────────────┬───────────────┤
│ Fields        │ Readonly      │
│ Storage       │ Stack/Inline  │
│ Equality      │ Value-based   │
│ Methods      │ Equals, GetHashCode, Deconstruct, with
│ Inheritance  │ None (interfaces only)
└───────────────┴───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do record structs support inheritance like classes? Commit yes or no.

Common Belief: Record structs can inherit from other structs or classes just like records or classes.

Reality: Record structs cannot inherit from any type; they are value types and only implement interfaces.

Why it matters: Assuming inheritance works leads to design errors and compiler errors, confusing developers and causing wasted effort.

Quick: Are record structs always faster than classes? Commit yes or no.

Common Belief: Record structs always perform better than classes because they avoid heap allocation.

Reality: Record structs can be slower if they are large and copied frequently, causing overhead compared to reference types passed by reference.

Why it matters: Misusing record structs for large data can degrade performance, negating their intended benefits.

Quick: Can you modify fields of a record struct after creation? Commit yes or no.

Common Belief: Record structs are mutable by default, so you can change their fields anytime.

Reality: Record structs are immutable by default; their fields are readonly and cannot be changed after creation.

Why it matters: Expecting mutability can cause bugs when code tries to modify fields and fails to compile or behaves unexpectedly.

Quick: Does 'with' expression create a new instance or modify the existing record struct? Commit your answer.

Common Belief: 'with' expressions modify the existing record struct instance in place.

Reality: 'with' expressions create a new record struct instance with specified changes, leaving the original unchanged.

Why it matters: Misunderstanding 'with' can lead to bugs where code assumes mutation but actually works with copies.

Expert Zone

1

Record structs generate compiler code that carefully balances immutability with performance, but subtle copying can occur in method calls or boxing, which experts must watch for.

2

The 'with' expression on record structs uses a synthesized copy constructor, which can be customized for advanced scenarios to control cloning behavior.

3

Implementing interfaces on record structs allows polymorphism but can cause boxing, so experts weigh interface use carefully to avoid performance hits.

When NOT to use

Avoid record structs for large data structures or when inheritance is required. Use classes or regular records instead for complex hierarchies or when reference semantics are needed. Also, avoid record structs if frequent mutation is necessary, as they are designed for immutability.

Production Patterns

In production, record structs are used for small immutable data like points, colors, or configuration values where performance matters. They often appear in graphics engines, game development, or high-performance data processing. Developers combine record structs with interfaces for flexible APIs and use 'with' expressions for safe updates.

Connections

Immutable data structures

Record structs are a form of immutable data structure in programming.

Understanding record structs deepens knowledge of how immutability improves safety and predictability in software design.

Value types vs Reference types

Record structs illustrate the differences and tradeoffs between value and reference types.

Knowing record structs clarifies when to use stack-based data versus heap-based objects, improving performance decisions.

Functional programming

Record structs support immutable data patterns common in functional programming.

Recognizing this connection helps apply functional principles in C# for safer, more maintainable code.

Common Pitfalls

#1 Trying to inherit from a record struct.

Wrong approach:

public record struct ColoredPoint : Point { public string Color; }

Correct approach:

public record struct ColoredPoint(int X, int Y, string Color);

Root cause:

Misunderstanding that structs cannot inherit from other types, unlike classes.

#2 Modifying fields of a record struct after creation.

Wrong approach:

var p = new Point(1, 2); p.X = 5;

Correct approach:

var p = new Point(1, 2); var p2 = p with { X = 5 };

Root cause:

Assuming record structs are mutable like regular structs or classes.

#3 Using record structs for large data causing performance issues.

Wrong approach:

public record struct LargeData(int[] Data1, int[] Data2, int[] Data3); // large arrays inside

Correct approach:

Use a class or record for large data to avoid copying overhead.

Root cause:

Not considering copying cost of large value types.

Key Takeaways

Record structs combine the efficiency of structs with the safety and convenience of records by providing immutable, value-based data types.

They are stored on the stack or inline, avoiding heap allocation and improving performance for small data objects.

Record structs automatically generate value equality, immutability, and cloning features, reducing boilerplate and bugs.

They cannot inherit from other types but can implement interfaces, balancing simplicity with flexibility.

Understanding when and how to use record structs helps write safer, clearer, and more efficient C# code.