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 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 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.