Span and Memory improve C# performance by reducing memory allocation. 1. Span avoids array copying, provides light references to existing memory, suitable for parsing binary protocols, string operations and high-performance buffer management; 2. Memory supports passing memory slices across asynchronous methods, suitable for scenarios where more flexible life cycles are required; 3. Both reduce GC pressure, optimize performance by reusing buffers, and avoiding temporary copying; 4. Span is limited to use on the stack, cannot be stored in classes or used for asynchronous methods, and be careful to avoid reassignment operations such as calling.ToArray().

When you're working with performance-sensitive code in C#, Span<t></t> and Memory<t></t> are powerful tools for reducing memory allocations and improving efficiency. They allow you to work with continuous regions of memory without copying data around, which is especially useful when handling arrays, buffers, or parsing data.

Here's how they help optimize memory usage and how you can use them effectively.

Avoiding unnecessary array copies with Span<t></t>

One of the main benefits of Span<t></t> is that it lets you slice and manipulate memory without creating new arrays. For example, if you have a large byte array and need to process just a portion of it, slicing the array traditionally would create a new array and copy data — which costs both time and memory.

With Span<byte></byte> , you can do this:

 byte[] data = GetData();
Span<byte> segment = data.AsSpan(100, 50); // No allocation, just a view

This avoids allocating a new array and instead give you a lightweight reference to the existing memory. Since Span<T> is a ref-like type, it can't be stored in classes or used across await or yield boundaries — but for stack-only operations, it's perfect.

Use cases:

• Parsing binary protocols
• String manipulation (especially with ReadOnlySpan<char> )
• Buffer management in high-performance scenarios

Using Memory<T> for flexible buffer handling

If you need to pass slices of memory across async methods or store them for a bit longer than what Span<T> allows, Memory<T> is your go-to. It supports the same slicing behavior as Span<T> , but it can live on the heap and be used more broadly.

For example:

 Memory<byte> buffer = new byte[1024];
ProcessHeader(buffer.Slice(0, 128)); // Passes a section of the buffer

Unlike Span<t></t> , Memory<t></t> can be stored in classes and passed between async methods. Under the hood, it wraps either managed arrays or native memory (via NativeMemory ), making it versatile.

Important note: When you need to access the actual memory from Memory<t></t> , you call .Span to get a Span<t></t> . This keeps performance tight where it matters.

Reducing garbage collection pressure

Every time you allocate an array or copy data into a new object, you increase GC pressure. Frequent allocations can lead to more frequent garbage collections, which hurts performance — especially in hot loops or real-time systems.

Using Span<t></t> and Memory<t></t> helps reduce this by:

• Reusing buffers (eg, via ArrayPool<t></t> )
• Avoiding temporary copies during string or data parsing
• Working directly on input buffers rather than extracting subsets into new objects

A practical pattern is combining these types with IBufferWriter<t></t> or PipeReader in ASP.NET Core pipelines, where performance and low allocation are critical.

Watch out for stack-only limitations of Span<t></t>

Since Span<t></t> is a ref struct, it can only live on the stack. That means you can't:

• Store it in a class
• Use it in async methods directly
• Return it from an iterator block
• Box it (eg, cast to object )

If you try, the compiler will complain — loudly. So while Span<t></t> is great for performance, it has sharp edges. If you need something more flexible, default to Memory<t></t> .

Also, avoid calling .ToArray() or new string(...) unless absolutely necessary — those reintroduce allocations and defeat the purpose.

In short, Span<t></t> and Memory<t></t> let you work with memory more efficiently by avoiding unequal copies and allocations. Use Span<t></t> where possible for best performance, and fall back to Memory<t></t> when you need more flexibility. Both play well with modern C# APIs like pipelines and pooled buffers.

That's about it — not magic, but definitely worth using right.

The above is the detailed content of How can Span and Memory be used in C# to optimize memory usage and reduce allocations?. For more information, please follow other related articles on the PHP Chinese website!