Span and Memory in C# — Zero-Allocation Slicing Explained

using System;
using System.Runtime.InteropServices;

public static class SpanInternalsDemo
{
    public static void Run()
    {
        // --- Scenario 1: Span over a heap-allocated array (most common) ---
        int[] heapArray = { 10, 20, 30, 40, 50, 60 };

        // No allocation here — Span is just a pointer + length on the stack
        Span<int> fullView = heapArray;
        Span<int> middleSlice = fullView.Slice(1, 4); // points at index 1, length 4

        Console.WriteLine("Middle slice from heap array:");
        foreach (int value in middleSlice)
            Console.Write($"{value} "); // 20 30 40 50
        Console.WriteLine();

        // Mutating through the Span mutates the original array — they share memory
        middleSlice[0] = 999;
        Console.WriteLine($"heapArray[1] after mutation via Span: {heapArray[1]}"); // 999

        // --- Scenario 2: Span over a stackalloc buffer (truly zero heap allocation) ---
        // stackalloc is only safe inside unsafe or with Span — Span wraps it safely
        Span<byte> stackBuffer = stackalloc byte[128];
        stackBuffer.Fill(0xFF); // fill all 128 bytes with 255

        Console.WriteLine($"\nFirst byte of stack buffer: {stackBuffer[0]}");  // 255
        Console.WriteLine($"Stack buffer length: {stackBuffer.Length}");        // 128

        // --- Scenario 3: Span over unmanaged memory ---
        nint unmanagedPtr = Marshal.AllocHGlobal(64);
        try
        {
            // Wrapping unmanaged memory in a Span — no GC involvement at all
            unsafe
            {
                Span<byte> unmanagedView = new Span<byte>((void*)unmanagedPtr, 64);
                unmanagedView.Clear(); // zero it out safely
                unmanagedView[0] = 42;
                Console.WriteLine($"\nUnmanaged byte[0]: {unmanagedView[0]}"); // 42
            }
        }
        finally
        {
            Marshal.FreeHGlobal(unmanagedPtr); // you must still manage lifetime manually
        }

        // --- Slicing a ReadOnlySpan<char> from a string (the parser pattern) ---
        string csvLine = "Alice,30,Engineer";
        ReadOnlySpan<char> lineSpan = csvLine.AsSpan();

        int firstComma = lineSpan.IndexOf(',');
        ReadOnlySpan<char> nameField = lineSpan.Slice(0, firstComma); // no String.Substring!

        // SequenceEqual lets you compare without allocating a new string
        bool isAlice = nameField.SequenceEqual("Alice");
        Console.WriteLine($"\nName field is 'Alice': {isAlice}"); // True
    }
}

using System;
using System.Buffers;
using System.Text;
using System.Threading.Tasks;

public static class MemoryAsyncPipelineDemo
{
    // Simulates reading a chunk of data asynchronously (e.g. from a socket)
    private static async Task<int> SimulateReadAsync(Memory<byte> destinationBuffer)
    {
        await Task.Delay(1); // represents real async I/O

        // Write some fake "received" data into the buffer
        byte[] fakePayload = Encoding.UTF8.GetBytes("HELLO:World");
        fakePayload.CopyTo(destinationBuffer);
        return fakePayload.Length; // return how many bytes were "read"
    }

    // Synchronous parser — takes Span<byte> because it never awaits
    private static (string command, string argument) ParseProtocolFrame(ReadOnlySpan<byte> frame)
    {
        int separatorIndex = frame.IndexOf((byte)':');
        if (separatorIndex < 0)
            return (Encoding.UTF8.GetString(frame), string.Empty);

        // Slice without any allocation — we're just adjusting a pointer + length
        ReadOnlySpan<byte> commandBytes = frame.Slice(0, separatorIndex);
        ReadOnlySpan<byte> argumentBytes = frame.Slice(separatorIndex + 1);

        // The only allocation is the final string we return — unavoidable for output
        return (Encoding.UTF8.GetString(commandBytes), Encoding.UTF8.GetString(argumentBytes));
    }

    public static async Task RunAsync()
    {
        // MemoryPool<byte>.Shared gives us a pooled buffer — no new byte[] on the heap
        using IMemoryOwner<byte> rentedBuffer = MemoryPool<byte>.Shared.Rent(minimumLength: 256);

        Console.WriteLine($"Rented buffer size: {rentedBuffer.Memory.Length} bytes");

        // Memory<byte> crosses the await boundary safely (it's a normal struct)
        int bytesRead = await SimulateReadAsync(rentedBuffer.Memory);

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

        // Now we're back from await — call .Span to get a synchronous view
        // Slice to only the bytes we actually received (don't parse garbage)
        ReadOnlySpan<byte> receivedData = rentedBuffer.Memory.Span.Slice(0, bytesRead);

        // Pass the Span to our zero-allocation parser
        var (command, argument) = ParseProtocolFrame(receivedData);

        Console.WriteLine($"Command : {command}");
        Console.WriteLine($"Argument: {argument}");

        // IMemoryOwner is IDisposable — the 'using' returns the buffer to the pool
        // No GC pressure from the buffer itself
    }

    // Demonstrating storing Memory<T> in a class field — impossible with Span<T>
    public class MessageBuffer
    {
        private readonly IMemoryOwner<byte> _owner;

        // Memory<byte> as a field: perfectly legal
        public Memory<byte> Data => _owner.Memory;

        public MessageBuffer(int capacity)
        {
            _owner = MemoryPool<byte>.Shared.Rent(capacity);
        }

        // Get a Span when you need to read/write synchronously
        public void WriteAscii(string text)
        {
            Span<byte> writableView = Data.Span; // this line would fail if Data were a field of type Span
            Encoding.ASCII.GetBytes(text, writableView);
        }

        public void Dispose() => _owner.Dispose();
    }
}

using System;
using System.Runtime.CompilerServices;

public static class ZeroAllocationCsvParser
{
    private const int MaxFieldsPerRow = 32; // stack-allocate space for up to 32 fields

    /// <summary>
    /// Parses a single CSV line into its fields.
    /// Allocates ONLY the returned string array — all intermediate work is on the stack.
    /// </summary>
    public static string[] ParseLine(ReadOnlySpan<char> csvLine, char delimiter = ',')
    {
        if (csvLine.IsEmpty)
            return Array.Empty<string>();

        // Stack-allocate an array of Range structs to track field boundaries
        // Range is a lightweight (int start, int end) struct — no heap allocation
        Span<Range> fieldRanges = stackalloc Range[MaxFieldsPerRow];
        int fieldCount = 0;
        int currentStart = 0;

        for (int charIndex = 0; charIndex <= csvLine.Length; charIndex++)
        {
            // Treat end-of-span as a virtual delimiter to capture the last field
            bool isDelimiter = charIndex == csvLine.Length || csvLine[charIndex] == delimiter;

            if (isDelimiter)
            {
                if (fieldCount >= MaxFieldsPerRow)
                    throw new InvalidOperationException(
                        $"CSV line exceeds maximum of {MaxFieldsPerRow} fields.");

                // Record the range of this field — no string created yet
                fieldRanges[fieldCount++] = new Range(currentStart, charIndex);
                currentStart = charIndex + 1;
            }
        }

        // Only NOW do we allocate — creating the output strings the caller will use
        string[] results = new string[fieldCount];
        for (int fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++)
        {
            ReadOnlySpan<char> fieldSpan = csvLine[fieldRanges[fieldIndex]];

            // Trim whitespace without allocating — Trim() on a span returns a span
            ReadOnlySpan<char> trimmedField = fieldSpan.Trim();

            // new string(ReadOnlySpan<char>) — this is the only heap allocation per field
            results[fieldIndex] = trimmedField.IsEmpty ? string.Empty : new string(trimmedField);
        }

        return results;
    }

    /// <summary>
    /// Processes each field without materializing ANY strings — peak zero-allocation.
    /// Use this when you're doing numeric parsing, validation, or routing — not string output.
    /// </summary>
    public static void ProcessFieldsWithoutAllocation(
        ReadOnlySpan<char> csvLine,
        char delimiter,
        FieldProcessor processor)
    {
        int currentStart = 0;
        int fieldIndex = 0;

        for (int i = 0; i <= csvLine.Length; i++)
        {
            if (i == csvLine.Length || csvLine[i] == delimiter)
            {
                ReadOnlySpan<char> field = csvLine.Slice(currentStart, i - currentStart).Trim();
                processor(fieldIndex++, field); // callback receives a span — no allocation
                currentStart = i + 1;
            }
        }
    }

    // Delegate type that receives a field as ReadOnlySpan<char> — avoids string allocation
    public delegate void FieldProcessor(int index, ReadOnlySpan<char> fieldValue);
}

// --- Demo entry point ---
public static class CsvParserDemo
{
    public static void Run()
    {
        string csvRow = "  Alice , 30 , Senior Engineer , London , true ";
        ReadOnlySpan<char> rowSpan = csvRow.AsSpan();

        // --- Version 1: Returns string[] — one allocation per field + the array ---
        Console.WriteLine("=== ParseLine (string[] output) ===");
        string[] fields = ZeroAllocationCsvParser.ParseLine(rowSpan);
        for (int i = 0; i < fields.Length; i++)
            Console.WriteLine($"  Field[{i}]: '{fields[i]}'");

        // --- Version 2: Callback with span — zero extra allocations ---
        Console.WriteLine("\n=== ProcessFieldsWithoutAllocation (zero alloc) ===");
        ZeroAllocationCsvParser.ProcessFieldsWithoutAllocation(
            rowSpan,
            delimiter: ',',
            processor: (index, fieldSpan) =>
            {
                // Parse an int inline without creating a string
                if (index == 1 && int.TryParse(fieldSpan, out int age))
                    Console.WriteLine($"  Age parsed inline (no string): {age}");
                else
                    Console.WriteLine($"  Field[{index}] length: {fieldSpan.Length} chars");
            }
        );

        // --- Demonstrate that spans correctly handle quoted/edge CSV ---
        Console.WriteLine("\n=== Edge case: single field ===");
        string[] singleField = ZeroAllocationCsvParser.ParseLine("OnlyOneField".AsSpan());
        Console.WriteLine($"  Fields found: {singleField.Length}, Value: '{singleField[0]}'");
    }
}

using System;
using System.Buffers;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

// Run with: dotnet run -c Release
// Add BenchmarkDotNet NuGet package first

[MemoryDiagnoser] // shows allocation column in BenchmarkDotNet output
[SimpleJob]
public class CsvParsingBenchmark
{
    private const string SampleRow = "Alice,30,Senior Engineer,London,true";

    // BASELINE: traditional approach — allocates on every call
    [Benchmark(Baseline = true)]
    public string[] TraditionalSplit()
    {
        // String.Split allocates a new string[] AND a new string for each field
        return SampleRow.Split(',');
    }

    // OPTIMISED: Span-based parser from the previous section
    [Benchmark]
    public string[] SpanBasedParse()
    {
        return ZeroAllocationCsvParser.ParseLine(SampleRow.AsSpan());
    }

    // PEAK: process without materialising any strings at all
    [Benchmark]
    public int SpanBasedCountCharsInAllFields()
    {
        int totalChars = 0;
        ZeroAllocationCsvParser.ProcessFieldsWithoutAllocation(
            SampleRow.AsSpan(),
            delimiter: ',',
            processor: (_, field) => totalChars += field.Length
        );
        return totalChars;
    }
}

// ============================================================
// PRODUCTION RULES — read these before shipping Span-based code
// ============================================================
public static class ProductionRules
{
    public static void Demonstrate()
    {
        // RULE 1: Never store the result of .AsSpan() across an await
        // This won't compile — it's a safety guarantee, not a limitation
        // async Task BadAsync(string input) {
        //     ReadOnlySpan<char> span = input.AsSpan(); // compile error CS4007
        //     await Task.Delay(1);
        //     Console.WriteLine(span[0]); // can never reach here
        // }

        // RULE 2: MemoryPool<T>.Shared is cheaper than new byte[] for buffers > 85KB
        // Arrays > 85KB go to the Large Object Heap (LOH) — renting avoids that entirely
        using IMemoryOwner<byte> largeBuffer = MemoryPool<byte>.Shared.Rent(100_000);
        Console.WriteLine($"Rented large buffer: {largeBuffer.Memory.Length} bytes — no LOH pressure");

        // RULE 3: ReadOnlySpan<char> comparisons are case-sensitive by default
        // Use MemoryExtensions.Equals for case-insensitive comparison
        ReadOnlySpan<char> headerName = "Content-Type".AsSpan();
        ReadOnlySpan<char> incoming = "content-type".AsSpan();

        bool caseSensitive = headerName.SequenceEqual(incoming);  // false
        bool caseInsensitive = MemoryExtensions.Equals(
            headerName, incoming, StringComparison.OrdinalIgnoreCase); // true

        Console.WriteLine($"Case-sensitive match: {caseSensitive}");    // False
        Console.WriteLine($"Case-insensitive match: {caseInsensitive}"); // True

        // RULE 4: stackalloc size should be capped and validated at runtime
        // Never stackalloc based on untrusted user input — stack overflow is unrecoverable
        int userInputLength = 64; // imagine this came from a request
        if (userInputLength > 1024)
            throw new ArgumentException("Input too large for stack buffer");

        Span<char> safeStackBuffer = stackalloc char[userInputLength];
        Console.WriteLine($"Safe stack buffer ready: {safeStackBuffer.Length} chars");
    }
}