What is Memory<T>?

Memory<T> is a type introduced in .NET to represent a contiguous region of memory. Unlike Span<T>, which is allocedted at the stack, Memory<T> is heap-allocated, making it compatible with asynchronous operations. It provides slicing capabilities to work with subsections of data without copying the original data.

How Memory<T> Solves Common Issues

1) Avoids Data Copying:
Traditionally, handling chunks of data involves creating new arrays, which incurs additional memory allocation and copying costs. Memory<T> solves this by allowing slices of existing data.

2) Asynchronous Compatibility:
Memory<T> can be passed to asynchronous methods without causing runtime issues.

3) Simplifies Complex Data Operations:
Memory<T> allows you to work with subsections of data while keeping the code clean and maintainable.

Example 1: Handling Large Datasets with Memory<T>

Imagine a scenario where you need to process large arrays by chunks.  The traditional approach for copying data would look somehow like:

class WithoutMemory
{
    static void Main()
    {
        int[] numbers = new int[100];
        for (int i = 0; i < numbers.Length; i++) numbers[i] = i + 1;

        ProcessChunksWithoutMemory(numbers, 10);
    }

    static void ProcessChunksWithoutMemory(int[] numbers, int chunkSize)
    {
        int totalChunks = (numbers.Length + chunkSize - 1) / chunkSize;

        for (int i = 0; i < totalChunks; i++)
        {
            int start = i * chunkSize;
            int length = Math.Min(chunkSize, numbers.Length - start);

            // Create a new array for each chunk
            int[] chunk = new int[length];
            Array.Copy(numbers, start, chunk, 0, length);

            Console.WriteLine($"Processing Chunk {i + 1}: {string.Join(", ", chunk)}");
        }
    }
}

But this approach involves creating new arrays and copying data for every chunk, which is inefficient.
A more optimized approach would be using Memory<T> like:

class WithMemory
{
    static void Main()
    {
        int[] numbers = new int[100];
        for (int i = 0; i < numbers.Length; i++) numbers[i] = i + 1;

        ProcessChunksWithMemory(numbers, 10);
    }

    static void ProcessChunksWithMemory(int[] numbers, int chunkSize)
    {
        Memory<int> memory = numbers;
        int totalChunks = (memory.Length + chunkSize - 1) / chunkSize;

        for (int i = 0; i < totalChunks; i++)
        {
            int start = i * chunkSize;
            int length = Math.Min(chunkSize, memory.Length - start);

            // Create a slice without copying data
            Memory<int> chunk = memory.Slice(start, length);

            Console.WriteLine($"Processing Chunk {i + 1}: {string.Join(", ", chunk.Span)}");
        }
    }
}

Example 2: Asynchronous Data Processing

Memory<T> is compatible with asynchronous methods, whereas Span<T> is not.  You can pass Memory<T> across await boundaries, making it suitable for async/await scenarios.

using System;
using System.Threading.Tasks;

class AsyncMemoryExample
{
    static async Task Main()
    {
        int[] numbers = new int[100];
        for (int i = 0; i < numbers.Length; i++) numbers[i] = i + 1;

        Memory<int> memory = numbers;

        await ProcessChunksAsync(memory, 10);
    }

    static async Task ProcessChunksAsync(Memory<int> memory, int chunkSize)
    {
        int totalChunks = (memory.Length + chunkSize - 1) / chunkSize;

        for (int i = 0; i < totalChunks; i++)
        {
            int start = i * chunkSize;
            int length = Math.Min(chunkSize, memory.Length - start);

            Memory<int> chunk = memory.Slice(start, length);
            Console.WriteLine($"Processing Chunk {i + 1}: {string.Join(", ", chunk.Span)}");

            // Simulate async work
            await Task.Delay(500);
        }
    }
}

Span<T> and Iterations - which kind of Iteration is the fastest?

For a C# array[] the iteration via for...each is the quickest way one can think of.

For a List<T> the use of a for loop is faster than the for...each approach.

However, the most efficient way to loop over a List<T> involves accessing the internal array[] via a Span<T> using

Span<int> span = CollectionsMarshal.AsSpan(list)

This approach is beneficial in performance-critical situations, provided that no elements are added or removed from the list.

Conclusion - when to Use Memory<T> and Span<T> ?

Use Memory<T> when:

• The operation involves asynchronous code.
• Data must persist beyond the scope of the current method.
• You need heap-allocated memory for long-lived tasks.

Use Span<T> when:

• The operation is short-lived and performance-critical.
• You want to avoid heap allocations entirely.
• You're working with stack-allocated data.