Differences Between Record Struct and Record Class in C#

Introduction to Records in C#

Introduced in C# 9.0, records provide a way to define immutable reference types with value semantics, focusing on data and its manipulation. Records simplify the syntax needed to create immutable objects, making code more concise and readable. With C# 10.0, Microsoft expanded this feature to include record struct, allowing the use of records as value types as well. This article explores the key differences between record class and record struct, providing examples and use cases to highlight their unique characteristics.

Understanding Record Class

A record class is a reference type in C#, meaning it is stored on the heap, and variables that reference records point to the same object in memory. Modifying the object through one reference reflects the change across all references.

Example:

public record class Person(string Name, int Age);

This Person record is immutable by default, meaning you cannot modify its properties after creation without creating a new instance.

Use Case:

Record class is ideal when you need to represent entities that should be shared or passed around without copying data. It suits scenarios like:

• Entity Modeling: Representing domain models in a business application where the same object needs to be passed between different layers of the application (e.g., service, data access).
• Equality Comparisons: Since record class overrides equality members (Equals and GetHashCode), it provides value-based equality, which is often useful for comparing instances.

Real-Life Example:

Imagine a system tracking users in a social media application. The record class can represent user profiles, ensuring that updates are reflected across the system without unnecessary data duplication.

public record class UserProfile(string Username, string Email);

When one component updates a user's email, all other components referencing that UserProfile object reflect the change.

Understanding Record Struct

A record struct is a value type, stored on the stack (unless boxed), with a distinct copy made each time it is passed to a method or assigned to a variable. This behavior contrasts with the record class, where only a reference is passed.

Example:

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

This Point struct represents an immutable point in a 2D space, and each assignment or pass by value creates a new copy.

Use Case:

Record struct is ideal for small data structures where performance is critical, and the overhead of heap allocation (as seen in classes) is unnecessary. Scenarios include:

• Mathematical Computations: Representing small, immutable data points like coordinates or colors where operations are frequently performed, and memory efficiency is essential.
• Data Transfer Objects (DTOs): When passing data between layers or microservices, where immutability and value semantics are required without the overhead of reference types.

Real-Life Example:

Consider a graphics application where points on a canvas are frequently manipulated. Using a record struct ensures that each operation creates a new point, preventing unintended side effects due to shared references.

public record struct CanvasPoint(int X, int Y);

Each time a point is moved or transformed, a new instance is created, preserving the original point's state.

Key Differences Between Record Class and Record Struct

Type:

• Record class is a reference type (heap allocation).
• Record struct is a value type (stack allocation).

Memory Management:

• Record class involves garbage collection and may incur more overhead due to heap allocation.
• Record struct is more memory-efficient for small, frequently used data structures.

Equality Semantics:

• Both provide value-based equality by default, but the record struct handles value semantics inherently due to its value type nature.

Copying Behavior:

• Record class copies references, meaning multiple references can point to the same object.
• Record struct copies the entire data, creating a distinct instance each time.

Mutability:

• Both are immutable by default, but the implications of immutability differ; record class protects shared references, while record struct ensures that each copy is independent.

Conclusion

Choosing between record class and record struct depends on the specific requirements of your application. Use record class when working with large or shared data models where reference semantics are preferred. Opt for record struct when dealing with small, immutable data structures where performance and memory efficiency are crucial. Understanding these differences allows developers to make informed decisions, optimizing their applications for both performance and maintainability.