Understanding Span<T> & Memory<T> for Low-Level Memory Efficiency

Both Span<T> and Memory<T> in .NET are designed for efficient memory handling, reducing allocations, and improving performance.

What is Span<T>?

Span<T> is a stack-allocated structure that allows working with contiguous memory regions efficiently.

Example

int[] numbers = { 1, 2, 3, 4, 5 };
Span span = numbers; span[0] = 10;
Console.WriteLine(numbers[0]);

// Output: 10

C#

Copy

Traditional string.Substring() creates a new string in memory, but Span<T> avoids extra allocations.

using System;

class Program
{
    static void Main()
    {
        string text = "Order1234: Processed";

        // Using Span<T> to extract parts of the string without creating new strings
        ReadOnlySpan<char> span = text.AsSpan();

        ReadOnlySpan<char> orderId = span.Slice(0, 10); // Extract "Order1234"
        ReadOnlySpan<char> status = span.Slice(12); // Extract "Processed"

        Console.WriteLine($"Order ID: {orderId.ToString()}");
        Console.WriteLine($"Status: {status.ToString()}");
    }
}

C#

Copy

Benefits: No extra memory allocation, improving performance for large string operations.

Key Points

• Does not allocate new memory.
• Works on arrays, stackalloc, and unmanaged memory.
• It can only be used in synchronous methods.

What is Memory<T>?

Memory<T> is similar to Span<T> but supports async operations since it is heap-allocated.

Example

Memory memory = new int[] { 1, 2, 3, 4, 5 };
Span spanFromMemory = memory.Span; spanFromMemory[0] = 20;
Console.WriteLine(memory.Span[0]);

// Output: 20

C#

Copy

When handling large data asynchronously (e.g., file I/O, network streams), Memory<T> is useful.

using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        byte[] buffer = new byte[1024]; // 1 KB buffer
        Memory<byte> memoryBuffer = buffer;

        using FileStream fileStream = new FileStream("largefile.txt", FileMode.Open, FileAccess.Read);
        int bytesRead = await fileStream.ReadAsync(memoryBuffer);

        Console.WriteLine($"Bytes Read: {bytesRead}");
    }
}

C#

Copy

Why Memory<T>? It supports sync operations and can be used without unsafe code while maintaining memory efficiency.

Key Points

• Supports async methods.
• Does not require fixed memory.
• Useful for working with large data sets.

When to Use Span<T> vs. Memory<T>?

Feature	Span<T>	Memory<T>
Allocation	Stack	Heap
Async Support	No	Yes
Performance	Higher	Lower

Conclusion

Use Span<T> for high-performance operations in synchronous code and Memory<T> for asynchronous workloads where heap allocation is necessary.

Span<T> and Memory<T> were introduced in .NET Core 2.1 and are also supported in,

• .NET Standard 2.1
• .NET Core 2.1+
• .NET 5+
• .NET 6, 7, 8 (latest versions)

However, the .NET Framework does not natively support Span<T>, but you can use the System.Memory NuGet package for partial support.