Unsafe Code, Spans and Performance

public static class SpanBasics
{
    public static int Sum(ReadOnlySpan<int> values)
    {
        int total = 0;

        foreach (int value in values)
        {
            total += value;
        }

        return total;
    }

    public static void Show()
    {
        int[] heap = [1, 2, 3, 4, 5];
        Span<int> stack = stackalloc int[5] { 1, 2, 3, 4, 5 };

        Console.WriteLine(Sum(heap));               // an array converts implicitly
        Console.WriteLine(Sum(stack));              // so does a stack buffer
        Console.WriteLine(Sum(heap.AsSpan(1, 3)));  // and a slice of one, with no copy
    }
}

public static class Slicing
{
    public static (int Year, int Month, int Day) ParseDate(ReadOnlySpan<char> text)
    {
        // "2026-09-11" parsed without a single string allocation.
        return (
            int.Parse(text[..4]),
            int.Parse(text.Slice(5, 2)),
            int.Parse(text.Slice(8, 2)));
    }
}

public static class Literals
{
    // No array is created; this points straight into the assembly metadata.
    private static ReadOnlySpan<byte> Magic => [0x50, 0x4B, 0x03, 0x04];

    public static bool IsZip(ReadOnlySpan<byte> header) => header.StartsWith(Magic);
}

public static class StackAllocation
{
    private const int MaxStack = 256;

    public static string ToHex(ReadOnlySpan<byte> data)
    {
        int needed = data.Length * 2;

        // Small on the stack, large on the heap -- the standard hybrid pattern.
        char[]? rented = needed > MaxStack ? System.Buffers.ArrayPool<char>.Shared.Rent(needed) : null;

        try
        {
            Span<char> buffer = rented is null ? stackalloc char[MaxStack] : rented;
            Span<char> target = buffer[..needed];

            for (int i = 0; i < data.Length; i++)
            {
                data[i].TryFormat(target.Slice(i * 2, 2), out _, "x2");
            }

            return new string(target);
        }
        finally
        {
            if (rented is not null)
            {
                System.Buffers.ArrayPool<char>.Shared.Return(rented);
            }
        }
    }
}

public static class RefBasics
{
    public static ref int Largest(int[] values)
    {
        int index = 0;

        for (int i = 1; i < values.Length; i++)
        {
            if (values[i] > values[index])
            {
                index = i;
            }
        }

        return ref values[index];           // an alias into the array
    }

    public static void Show()
    {
        int[] numbers = [3, 9, 4];

        ref int largest = ref Largest(numbers);
        largest = 0;                        // writes through the alias

        Console.WriteLine(numbers[1]);      // 0

        // A readonly alias: no copy on read, no write allowed.
        ref readonly int peek = ref numbers[0];
        Console.WriteLine(peek);
    }
}

public ref struct Cursor
{
    private ref int _current;
    private int _remaining;

    public Cursor(Span<int> values)
    {
        _current = ref System.Runtime.InteropServices.MemoryMarshal.GetReference(values);
        _remaining = values.Length;
    }

    public bool TryAdvance(out int value)
    {
        if (_remaining == 0)
        {
            value = 0;
            return false;
        }

        value = _current;
        _current = ref System.Runtime.CompilerServices.Unsafe.Add(ref _current, 1);
        _remaining--;
        return true;
    }
}

public static class Scoped
{
    // `scoped` says: this span does not escape, so a stackalloc'd buffer is safe to pass.
    public static int Consume(scoped ReadOnlySpan<char> text) => text.Length;
}

public static unsafe class Pointers
{
    public static int SumViaPointer(int[] values)
    {
        int total = 0;

        // `fixed` pins the array so the GC cannot move it while the pointer exists.
        fixed (int* start = values)
        {
            int* end = start + values.Length;

            for (int* p = start; p < end; p++)
            {
                total += *p;                    // dereference
            }
        }

        return total;
    }

    public static void MemberAccess()
    {
        Sample sample = new() { Value = 7 };
        Sample* pointer = &sample;              // address-of, on a local

        Console.WriteLine(pointer->Value);      // member access through a pointer
        Console.WriteLine((*pointer).Value);    // equivalent

        Console.WriteLine(sizeof(Sample));      // size in bytes, no unsafe needed for unmanaged types
    }

    public struct Sample
    {
        public int Value;
    }
}

public unsafe struct Packet
{
    // A fixed-size buffer: 16 bytes inline in the struct, not a separate array object.
    public fixed byte Header[16];
    public int Length;

    public byte FirstHeaderByte()
    {
        fixed (byte* header = Header)
        {
            return header[0];
        }
    }
}

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

public static class MarshalHelpers
{
    // Reinterpret a span of bytes as a span of ints -- no copy, no pointer.
    public static ReadOnlySpan<int> AsInts(ReadOnlySpan<byte> bytes) =>
        MemoryMarshal.Cast<byte, int>(bytes);

    // Read a struct straight out of a byte buffer.
    public static T Read<T>(ReadOnlySpan<byte> source) where T : struct =>
        MemoryMarshal.Read<T>(source);

    // A single struct viewed as the span of bytes that make it up.
    public static Span<byte> AsBytes<T>(ref T value) where T : unmanaged =>
        MemoryMarshal.AsBytes(new Span<T>(ref value));

    // Bounds-check-free element access in a loop whose bounds are already proven.
    public static int SumUnchecked(ReadOnlySpan<int> values)
    {
        ref int first = ref MemoryMarshal.GetReference(values);
        int total = 0;

        for (int i = 0; i < values.Length; i++)
        {
            total += Unsafe.Add(ref first, i);
        }

        return total;
    }
}

using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct FileHeader
{
    public uint Signature;
    public ushort Version;
    public ushort Flags;
}

[StructLayout(LayoutKind.Explicit)]
public struct FloatBits
{
    [FieldOffset(0)] public float Value;
    [FieldOffset(0)] public uint Bits;      // the same four bytes, viewed as an integer
}

using System.Runtime.CompilerServices;

public static class AllocationTechniques
{
    // 1. Take spans, not strings/arrays, in parsing APIs.
    public static bool StartsWithHeader(ReadOnlySpan<char> line) => line.StartsWith("HDR");

    // 2. Format into a caller-supplied buffer instead of returning a new string.
    public static bool TryFormat(int value, Span<char> destination, out int written) =>
        value.TryFormat(destination, out written);

    // 3. Use static lambdas so no closure object is created.
    public static int CountEven(IEnumerable<int> values) => values.Count(static n => n % 2 == 0);

    // 4. Use `string.Create` to build a string in one pass, with no intermediate.
    public static string Repeat(char c, int count) =>
        string.Create(count, c, static (span, value) => span.Fill(value));

    // 5. Avoid boxing: generic constraints instead of `object` parameters.
    public static T Max<T>(T a, T b) where T : IComparable<T> => a.CompareTo(b) >= 0 ? a : b;
}

public class Buffer15
{
    // Under the C# 15 model a pointer-typed field no longer needs an `unsafe` context.
    private byte* _data;
    private int _length;

    public int Length => _length;

    public byte ReadAt(int index)
    {
        // `unsafe(expr)` marks exactly the unverifiable operation, not the whole method.
        return unsafe(_data[index]);
    }
}

dotnet new console -o Benchmarks
cd Benchmarks
dotnet add package BenchmarkDotNet
dotnet run -c Release          # benchmarks must be run in Release, never under a debugger

// Sketch of a BenchmarkDotNet harness (the package is not referenced by this documentation build).
// [MemoryDiagnoser]
// public class ParsingBenchmarks
// {
//     private readonly string _input = "2026-09-11";
//
//     [Benchmark(Baseline = true)]
//     public int Substring() => int.Parse(_input.Substring(0, 4));
//
//     [Benchmark]
//     public int Span() => int.Parse(_input.AsSpan(0, 4));
// }
public static class BenchmarkNote
{
    public static string Guidance =>
        "Measure in Release, outside the debugger, with MemoryDiagnoser enabled.";
}