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

Dashrath Hapani
1w
296
0
4

Article

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

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()}");
    }
}

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

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}");
    }
}

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

Key Points