C# Performance Hack: Use record struct for Small, Immutable Models

When designing data models in C#, the choice between class, struct, and record can significantly impact performance and memory usage.

But what makes record struct such a good fit for lightweight models compared to classes?

Classes: The Default Choice

By default, most developers reach for class. Classes are reference types:

They live on the heap.
Variables hold references (pointers) to objects.
Garbage Collection (GC) must clean them up when they are no longer used.

Advantage: Good for large, complex objects that are shared or mutated.

Disadvantage: Overkill for small, short-lived, immutable data models.

Structs

A struct is a value type:

Allocated on the stack.
Copied by value, not reference.
Faster for small, short-lived objects.
No GC overhead for stack allocations.

Advantage: Ideal for lightweight data carriers.

Disadvantage: But normal struct lacks the immutability and equality benefits of record.

Records

A reference type.
Record classes behave similarly to regular classes in terms of memory allocation (on the heap) and assignment (reference copying).
Value-based equality (== compares properties, not references).

public record Point(int X, int Y);

var p1 = new Point(5, 10);
var p2 = new Point(5, 10);
var p3 = new Point(10, 20);

Console.WriteLine(p1 == p2); // True (same values)
Console.WriteLine(p1 == p3); // False (different values)

// For classes:
public class PointClass
{
    public int X { get; init; }
    public int Y { get; init; }
}

var c1 = new PointClass { X = 5, Y = 10 };
var c2 = new PointClass { X = 5, Y = 10 };

Console.WriteLine(c1 == c2); // False (different references)

Record Struct: The Best of Both Worlds

Combines the performance of a struct (stack-allocated, lightweight).
With the features of a record (immutability, value equality, with expressions).

public readonly record struct Point(int X, int Y);

var p1 = new Point(10, 20);
var p2 = new Point(10, 20);

// Value equality
Console.WriteLine(p1 == p2); // True

// With-expression works
var p3 = p1 with { X = 30 };

Console.WriteLine(p3); // Point { X = 30, Y = 20 }

=> This makes the record struct perfect for lightweight models.

When to Use Record Struct

Use record struct when:

You need small, immutable, value-like models.
You care about low memory and avoiding heap/GC overhead.

Stick to class when:

Objects are large, complex, or mutable.
You need shared instances.