Zero allocation techniques in C#: Using ref struct and readonly struct

Memory allocation plays a crucial role in the performance of any application, particularly when working with real-time systems or high-performance computing.

One effective way to optimize your C# code is by employing zero-allocation techniques. In this article, we’ll discuss two powerful tools available in C# for this purpose: ref struct and readonly struct.

We’ll explain these concepts in detail, illustrate their differences, and show how you can use them to reduce memory allocations and improve runtime efficiency.

Understanding Memory Allocation

In .NET, memory is divided into two main areas: the stack and the heap. When you allocate an object, it usually goes on the heap, whereas value types (like int or custom structs) are allocated on the stack.

The stack has limited space, but it is much faster for short-term memory because it is automatically cleaned up when the current method call is complete.

The heap, on the other hand, requires garbage collection, which can be costly in terms of performance.

To minimize heap allocations and avoid the overhead of garbage collection, developers can use constructs such as ref struct and readonly struct in C#. Let’s dive into each of these features.

What is a ref struct?

A ref struct is a special type of struct in C# that can only be allocated on the stack. This makes it suitable for scenarios where heap allocation would be undesirable due to performance concerns.

By using ref struct, you ensure that the object exists only within the method call and cannot escape the stack.

Characteristics of ref struct

• Stack-Only Allocation: ref struct instances are always stored on the stack, which guarantees better performance by avoiding garbage collection.
• No Boxing: Since boxing would move an object to the heap, ref struct cannot be boxed. This means it cannot implement interfaces, and the object type cannot be assigned.
• Span<T>: One of the most common examples of ref struct is Span<T>, a powerful type that enables slicing arrays, strings, or other memory regions without additional heap allocation.

When to use ref struct

ref struct is useful when dealing with high-performance applications, like parsing data or working with buffers. Since the stack is much faster for short-lived objects, using ref struct can help you manage memory efficiently.

Example code: Using ref struct

Let’s consider an example where we use a ref struct to handle a simple buffer operation.

public ref struct BufferProcessor
{
    private Span<byte> _buffer;

    public BufferProcessor(Span<byte> buffer)
    {
        _buffer = buffer;
    }

    public void ProcessData()
    {
        for (int i = 0; i < _buffer.Length; i++)
        {
            _buffer[i] = (byte)(i % 256); // Example processing logic
        }
    }
}

public class Example
{
    public static void Main()
    {
        byte[] data = new byte[1024];
        var buffer = new Span<byte>(data);
        var processor = new BufferProcessor(buffer);
        processor.ProcessData();
    }
}

In this example, BufferProcessor is a ref struct, and its main purpose is to work with Span<byte>, which is also a ref struct.

Since both are allocated on the stack, this prevents unnecessary heap allocations and avoids the overhead of garbage collection.

What is a readonly struct?

A readonly struct is a struct that is immutable by design, meaning that its fields cannot be modified after initialization. readonly struct is a great way to ensure immutability without compromising performance, as it allows for optimizations during compilation.

Characteristics of readonly struct

• Immutability: The primary purpose of readonly struct is to enforce immutability, which helps in scenarios where data consistency is paramount.
• Performance: By marking a struct as readonly, you help the compiler apply certain optimizations, such as eliminating defensive copies, which can improve performance.
• No Modification: Fields of a readonly struct cannot be changed once assigned.

When to use readonly struct

readonly struct is ideal for representing data that should not change after creation, such as mathematical vectors, points in space, or configuration parameters.

Example code: Using readonly struct

Here’s a simple example that demonstrates how to use a readonly struct to represent a 2D point.

public readonly struct Point2D
{
    public double X { get; }
    public double Y { get; }

    public Point2D(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double DistanceTo(Point2D other)
    {
        return Math.Sqrt(Math.Pow(other.X - X, 2) + Math.Pow(other.Y - Y, 2));
    }
}

public class Example
{
    public static void Main()
    {
        var point1 = new Point2D(0, 0);
        var point2 = new Point2D(3, 4);

        double distance = point1.DistanceTo(point2);
        Console.WriteLine($"Distance between points: {distance}");
    }
}

In this code, Point2D is a readonly struct, ensuring that once a Point2D instance is created, its X and Y values cannot be modified.

This helps keep the data consistent and prevents unintended changes, which is critical when working with geometrical data.

Combining ref struct and readonly struct for performance

One interesting scenario involves combining both ref struct and readonly struct concepts to maximize performance and minimize allocations.

For instance, you may have a readonly ref struct to process immutable data on the stack, ensuring no heap allocations and immutability simultaneously.

Example Code: readonly ref struct

public readonly ref struct ReadOnlyBufferProcessor
{
    private readonly ReadOnlySpan<byte> _buffer;

    public ReadOnlyBufferProcessor(ReadOnlySpan<byte> buffer)
    {
        _buffer = buffer;
    }

    public void DisplayBufferContent()
    {
        foreach (var b in _buffer)
        {
            Console.WriteLine(b);
        }
    }
}

public class Example
{
    public static void Main()
    {
        byte[] data = { 1, 2, 3, 4, 5 };
        var readOnlyBuffer = new ReadOnlySpan<byte>(data);
        var processor = new ReadOnlyBufferProcessor(readOnlyBuffer);
        processor.DisplayBufferContent();
    }
}

Here, ReadOnlyBufferProcessor is a readonly ref struct that uses ReadOnlySpan<byte>, providing a zero-allocation way to read and display the contents of a byte array.

The combination of stack-only allocation and immutability makes this solution highly performant.

Summary

In this article, we explored two critical techniques for achieving zero allocations in C#: ref struct and readonly struct.

By allocating structs on the stack and ensuring immutability where appropriate, we can dramatically reduce the overhead associated with heap allocations and garbage collection.

• ref struct: Useful for stack-only operations, ideal for scenarios involving temporary buffers and high-performance parsing.
• readonly struct: Ideal for representing immutable data, ensuring that the values do not change, which helps in maintaining consistency and applying compiler optimizations.

These two features are instrumental when writing high-performance code in C#, particularly in environments where managing memory allocations efficiently is crucial.

Next Steps

If you found this article helpful, consider diving deeper into topics such as Span<T>, Memory<T>, and other stack-based memory management techniques in .NET.

Experiment with using ref struct and readonly struct in your code to see the performance benefits firsthand!

Happy coding!