CS4007 - Async Span Prevents Dangling Pointer

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

using System;

public static class DecisionTree
{
    public static void Demonstrate()
    {
        byte[] heapArray = new byte[1024];
        
        // If your method is synchronous and you own the slice lifetime, use Span:
        ProcessChunkSync(heapArray.AsSpan(0, 512));
        
        // If your method queues async work or stores the data, use Memory:
        ProcessChunkAsync(heapArray.AsMemory(0, 512));
    }

    // Prefer Span in synchronous helpers
    private static void ProcessChunkSync(Span<byte> chunk)
    {
        // Process chunk immediately
        Console.WriteLine($"Processing {chunk.Length} bytes synchronously");
    }

    // Prefer Memory in async or stateful APIs
    private static async Task ProcessChunkAsync(Memory<byte> chunk)
    {
        // Queue to background processing (simulated)
        await Task.Run(() =>
        {
            // Access data via .Span inside the synchronous callback
            ReadOnlySpan<byte> localView = chunk.Span;
            Console.WriteLine($"Processing {localView.Length} bytes asynchronously");
        });
    }
}

// io.thecodeforge — csharp tutorial

// DON'T do this — the span outlives the borrowed buffer
public class CsvRowAccessor
{
    private Span<byte> _rowSpan;
    private byte[] _sharedBuffer;

    public void Bind(byte[] buffer, int offset, int length)
    {
        _sharedBuffer = buffer;          // kept alive
        _rowSpan = buffer.AsSpan(offset, length); // dangling if buffer is reassigned externally
    }
}

// SAFE: use Memory<T> as the contract
public class SafeCsvRowAccessor
{
    private Memory<byte> _rowMemory;

    public void Bind(Memory<byte> chunk) => _rowMemory = chunk;
    public Span<byte> GetSpanForFastRead() => _rowMemory.Span; // short-lived borrow
}

// io.thecodeforge — csharp tutorial

public static class LogFieldExtractor
{
    public static ReadOnlySpan<char> ExtractField(ReadOnlySpan<char> line, int fieldIndex)
    {
        int start = 0;
        int currentField = 0;

        for (int i = 0; i < line.Length; i++)
        {
            if (line[i] == '|')
            {
                if (currentField == fieldIndex)
                    return line.Slice(start, i - start);
                
                currentField++;
                start = i + 1;
            }
        }

        return currentField == fieldIndex ? line.Slice(start) : ReadOnlySpan<char>.Empty;
    }
}

// Usage — no allocation until ToString()
ReadOnlySpan<char> logLine = "ERROR|2024-03-15|Connection timeout|node-42";
var severity = LogFieldExtractor.ExtractField(logLine, 0);
var message = LogFieldExtractor.ExtractField(logLine, 2);
Console.WriteLine(severity.ToString()); // only this allocates

// io.thecodeforge — csharp tutorial

using System;
using System.Buffers;

public sealed class BufferProcessor : IDisposable
{
    private readonly IMemoryOwner<byte> _owner;
    private readonly Memory<byte> _buffer;

    // Constructor accepts ownership — caller relinquishes control
    public BufferProcessor(IMemoryOwner<byte> owner)
    {
        _owner = owner ?? throw new ArgumentNullException(nameof(owner));
        _buffer = owner.Memory;
    }

    // Consumer method — does NOT mutate or dispose
    public ReadOnlySpan<byte> GetSlice(int start, int length)
    {
        return _buffer.Span.Slice(start, length);
    }

    public void Dispose()
    {
        _owner?.Dispose();
    }
}

// io.thecodeforge — csharp tutorial

using System;
using System.Buffers;

public class PacketReader
{
    private readonly ArrayPool<byte> _pool = ArrayPool<byte>.Shared;

    // Accepts Memory<T> — but caller must guarantee the buffer is
    // NOT from a pool if they expect us to consume only.
    public int ReadHeader(Memory<byte> buffer)
    {
        // Consumer — no ownership taken
        return buffer.Span[0]; // first byte as header length
    }

    // Returns a rented buffer as Memory<T> — BEWARE: ownerless
    public Memory<byte> AllocateTempBuffer(int size)
    {
        byte[] rented = _pool.Rent(size);
        // Caller cannot return this to pool — Memory<T> is opaque
        return rented.AsMemory(0, size);
    }
}

// io.thecodeforge — csharp tutorial

using System;

public class SpanFeatures
{
    public static void Run()
    {
        int[] arr = [1, 2, 3, 4, 5];
        Span<int> span = arr.AsSpan(1, 3); // slice, no allocation
        span[0] = 99; // modifies original array
        Console.WriteLine(arr[1]); // 99

        ReadOnlySpan<char> text = "Hello World".AsSpan();
        ReadOnlySpan<char> world = text.Slice(6); // zero substring
        Console.WriteLine(world.ToString()); // World
    }
}

// io.thecodeforge — csharp tutorial

using System;

public class KeyTakeaways
{
    public static void Process(ReadOnlyMemory<char> memory)
    {
        // Use Span<T> for synchronous fast path
        ReadOnlySpan<char> span = memory.Span;
        if (span.Length > 5)
            Console.WriteLine(span[..5].ToString());

        // Use Memory<T> when task returns or storing
        _ = memory.Slice(0, 3); // no allocation
    }
}

// io.thecodeforge — csharp tutorial
// Owner/consumer with counted ownership
using System;
using System.Buffers;
using System.Threading.Tasks;

class BufferOwner
{
    public async Task RunAsync()
    {
        byte[] rented = ArrayPool<byte>.Shared.Rent(1024);
        var memory = new Memory<byte>(rented, 0, 256);
        int useCount = 2;
        
        Task consumer1 = ConsumeAsync(memory, ref useCount, () => 
            ArrayPool<byte>.Shared.Return(rented));
        Task consumer2 = ConsumeAsync(memory, ref useCount, () => 
            ArrayPool<byte>.Shared.Return(rented));
        
        await Task.WhenAll(consumer1, consumer2);
    }
}

async Task ConsumeAsync(Memory<byte> mem, ref int count, Action release) { }

// io.thecodeforge — csharp tutorial
// Ownerless memory from string slicing
using System;
using System.Threading.Tasks;

class OwnerlessDemo
{
    public async Task RunAsync()
    {
        string huge = new string('a', 10_000);
        ReadOnlyMemory<char> slice = huge.AsMemory(50, 100);
        
        // No pool, no owner — safe across await
        await ProcessAsync(slice);
    }
    
    async Task ProcessAsync(ReadOnlyMemory<char> mem)
    {
        Console.WriteLine(mem.Length); // 100
        await Task.Delay(1);
        // Runtime still holds reference to original string
    }
}