Ever had a seemingly innocuous value type mutate unexpectedly? That tiny side effect can snowball into a debugging nightmare. Enter readonly struct in C# — a feature designed to give you immutability and performance in one clean package.
A readonly struct guarantees that all its fields are immutable after construction. This means once you create an instance, its state can’t be changed. That might sound restrictive, but it prevents unintentional mutations especially when structs are passed by reference, like in in parameters.
Here’s a practical example:
readonly struct Vector2D
{
public double X { get; }
public double Y { get; }
public Vector2D(double x, double y)
{
X = x;
Y = y;
}
public double Magnitude => Math.Sqrt(X * X + Y * Y);
}This Vector2D struct is safe from accidental modifications. Try setting X or Y after construction, and the compiler will stop you. Not only does this enhance predictability, but it also allows the JIT compiler to optimize more aggressively due to the immutability guarantee.
Keep in mind: once you mark a struct as readonly, every field must be immutable, and methods can’t mutate this. Also, beware of using mutable reference types inside a readonly struct; the struct itself won’t change, but the object it references can.
In performance-critical code, like game development or high-frequency calculations, the benefits are tangible: less defensive copying, better cache coherence, and fewer bugs.
So next time you’re designing a value type, ask yourself: does it need to be mutable? If not, go readonly. It’s a small keyword with a big impact.
Have you used readonly struct in a real-world project? Share your story in the comments!
