C sharp - Span and Memory for High-Performance Programming in C#

Modern C# introduces Span and Memory as powerful abstractions for working with contiguous memory efficiently. These types are designed to reduce unnecessary memory allocations and improve performance, especially in scenarios involving large data processing, buffers, or real-time systems.

1. What is Span?

Span is a lightweight, stack-only type that represents a contiguous region of arbitrary memory. It can point to:

  • Arrays

  • Portions of arrays (slices)

  • Stack-allocated memory

  • Unmanaged memory

The key feature of Span is that it allows you to work with slices of data without copying it, which significantly improves performance.

Example:

int[] numbers = { 1, 2, 3, 4, 5 };
Span<int> span = numbers.AsSpan(1, 3); // Represents {2, 3, 4}

foreach (var num in span)
{
    Console.WriteLine(num);
}

In this example, no new array is created. The span simply references a portion of the original array.

2. Key Characteristics of Span

  • It is a ref struct, meaning it is allocated on the stack.

  • It cannot be boxed, stored in fields, or used in async methods.

  • It provides safe access to memory with bounds checking.

  • It avoids heap allocations, reducing garbage collection overhead.

3. What is Memory?

Memory is similar to Span, but it is designed to work in scenarios where Span cannot be used.

Unlike Span, Memory:

  • Can be stored on the heap

  • Can be used in async and await methods

  • Can be passed across method boundaries safely

Example:

int[] numbers = { 1, 2, 3, 4, 5 };
Memory<int> memory = numbers.AsMemory(1, 3);

Span<int> span = memory.Span;
foreach (var num in span)
{
    Console.WriteLine(num);
}

Memory acts as a more flexible wrapper, while Span is used for actual fast memory access.

4. Why Use Span and Memory?

a. Avoiding Memory Allocations

Traditional approaches like Array.Copy or Substring create new objects in memory. Span allows slicing without allocation.

b. Improved Performance

By reducing heap allocations, applications experience:

  • Less garbage collection

  • Lower latency

  • Better throughput

c. Safer Alternative to Pointers

Span provides memory safety with bounds checking, unlike unsafe pointer operations.

5. Practical Use Cases

a. String Manipulation Without Allocation

string text = "HelloWorld";
ReadOnlySpan<char> span = text.AsSpan(5);

Console.WriteLine(span.ToString()); // Output: World

b. Buffer Handling

Used in high-performance applications such as:

  • Networking

  • File processing

  • Real-time systems

c. Parsing Data Efficiently

ReadOnlySpan<char> data = "12345".AsSpan();
int number = int.Parse(data);

No intermediate string allocation is needed.

6. Limitations of Span

  • Cannot be used in async methods

  • Cannot be stored in class fields

  • Lifetime is limited to the method scope

  • Cannot cross thread boundaries safely

These restrictions exist to ensure memory safety.

7. When to Use Span vs Memory

Scenario Recommended Type
Synchronous, short-lived operations Span
Async or long-lived storage Memory
High-performance inner loops Span
Passing data across layers Memory

8. ReadOnlySpan and ReadOnlyMemory

These are immutable versions used when data should not be modified.

Example:

ReadOnlySpan<char> span = "Hello".AsSpan();

They improve safety by preventing accidental data modification.

9. Performance Impact

Using Span and Memory can:

  • Reduce memory allocations significantly

  • Minimize garbage collection pauses

  • Improve execution speed in critical applications

They are widely used in modern .NET libraries for optimized performance.

Conclusion

Span and Memory are essential tools for writing high-performance C# applications. Span is ideal for fast, short-lived operations on memory, while Memory provides flexibility for asynchronous and long-lived scenarios. By avoiding unnecessary allocations and enabling safe memory access, these types help developers build efficient and scalable systems.