Bits of .NET

How to achieve extreme performance in .NET 9 by mastering Span<T>, Memory<T>, and the Garbage Collector.

In the world of cloud-native development, Memory is Money. Every byte you allocate on the Managed Heap is a debt that the Garbage Collector (GC) must eventually collect.

The biggest bottleneck in high-throughput .NET applications isn’t typically the CPU’s raw speed—it’s the GC Pauses. When your app allocates too many objects, the GC has to stop the world to clean up the mess. But what if you could write code that allocates nothing?

The “Hidden” Cost of Strings and Arrays

Consider a simple task: Parsing a substring from a large CSV or JSON payload. In traditional C#, we do this:

// THE OLD WAY: High Allocation
public string GetUserId(string data) 
{
    // Substring() creates a BRAND NEW string object on the Heap
    return data.Substring(7, 10); 
}

If this method is called 10,000 times per second, you are creating 10,000 objects every second just to discard them immediately. This is Heap Pollution.

---

Enter: Span<T> and the Stack Revolution

Introduced to make .NET as fast as C++, Span<T> allows us to point to a section of memory without creating a copy. It lives on the Stack, meaning it costs the GC exactly zero.

// THE MODERN WAY: Zero Allocation
public ReadOnlySpan<char> GetUserIdFast(string data) 
{
    // AsSpan() points to the existing memory. No new string created.
    return data.AsSpan(7, 10); 
}

[Image: Performance Benchmark Chart showing Span vs Substring latency]

Why .NET 9 Developers Can’t Ignore This

In the era of .NET 9, performance isn’t just about “speed”—it’s about Cloud Efficiency.

Feature	Heap Allocation	Zero-Allocation Pattern
String Slicing	Substring()	AsSpan()
Async Methods	Task<T>	ValueTask<T>
Buffer Management	new byte[]	ArrayPool<T>.Shared

The Result: Higher Throughput, Lower Bill

By moving from Task to ValueTask and using ArrayPool for temporary buffers, we recently saw a 40% reduction in memory usage in a high-traffic payment gateway.

When you stop making the GC work so hard, your CPU cycles are finally free to do what they were meant for: Executing your business logic.

Write Fast. Allocate Less.