Unsafe Code in C#: Pointers, Memory and Performance Unlocked

using System;
using System.Runtime.InteropServices;

// Compile with: dotnet run  (project must have <AllowUnsafeBlocks>true</AllowUnsafeBlocks>)
// or csc /unsafe MemoryPinningDemo.cs

class MemoryPinningDemo
{
    static unsafe void Main()
    {
        // ── SCENARIO 1: Pinning a managed array on the heap ──────────────────
        byte[] pixelBuffer = new byte[8];
        for (int i = 0; i < pixelBuffer.Length; i++)
            pixelBuffer[i] = (byte)(i * 10); // fill with 0,10,20,30,40,50,60,70

        Console.WriteLine("Before fixed block:");
        Console.WriteLine($"  Managed array address (approx): {GC.GetGeneration(pixelBuffer)}");

        fixed (byte* bufferPtr = pixelBuffer)
        {
            // GC is now forbidden from moving pixelBuffer until we exit this block.
            // bufferPtr is a raw memory address — no bounds checking from here.
            Console.WriteLine($"\nInside fixed block (pinned):");

            for (int offset = 0; offset < 8; offset++)
            {
                // Pointer arithmetic: bufferPtr + offset moves sizeof(byte)*offset bytes forward
                byte value = *(bufferPtr + offset);
                Console.WriteLine($"  *(bufferPtr + {offset}) = {value}");
            }

            // Write directly through the pointer — no array bounds check at runtime
            *(bufferPtr + 3) = 99; // overwrite index 3
            Console.WriteLine($"\n  After pointer write, pixelBuffer[3] = {pixelBuffer[3]}");
        }
        // GC is free to compact again the moment we exit the fixed block.

        // ── SCENARIO 2: Stack allocation — no GC involvement at all ──────────
        Console.WriteLine("\nstackalloc demo:");

        // Allocates 16 bytes directly on the current thread stack.
        // Automatically reclaimed when this method returns — like a local variable.
        byte* stackBuffer = stackalloc byte[16];

        for (int i = 0; i < 16; i++)
            stackBuffer[i] = (byte)(i + 1); // fill with 1..16

        // Span<T> gives us safe, bounds-checked access over the raw pointer
        Span<byte> safeView = new Span<byte>(stackBuffer, 16);
        Console.WriteLine($"  stackBuffer[0]  = {safeView[0]}");
        Console.WriteLine($"  stackBuffer[15] = {safeView[15]}");

        // ── SCENARIO 3: Getting the size of a type at compile time ───────────
        Console.WriteLine($"\nsizeof(int)    = {sizeof(int)}  bytes");
        Console.WriteLine($"sizeof(double) = {sizeof(double)} bytes");
        // sizeof() on managed types (with references) requires unsafe context
        // sizeof() on primitives is available everywhere
    }
}

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

// Represents a single pixel in RGBA format — exactly 4 bytes, no padding
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct RgbaPixel
{
    public byte Red;
    public byte Green;
    public byte Blue;
    public byte Alpha;
}

// Simulates a minimal 4-byte network packet header
[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct PacketHeader
{
    public byte  Version;       // 1 byte
    public byte  MessageType;   // 1 byte
    public ushort PayloadLength; // 2 bytes (big-endian on the wire — we'll handle that)
}

class PointerArithmeticAndReinterpret
{
    // ── DEMO 1: Walk RGBA pixel buffer with pointer arithmetic ───────────────
    static unsafe void ProcessPixelBuffer()
    {
        // 4 pixels × 4 bytes each = 16 bytes total
        byte[] rawImageData = {
            255,   0,   0, 255,  // Pixel 0: Red
              0, 255,   0, 255,  // Pixel 1: Green
              0,   0, 255, 255,  // Pixel 2: Blue
            128, 128, 128, 255   // Pixel 3: Grey
        };

        Console.WriteLine("=== RGBA Pixel Walk via Pointer ===");

        fixed (byte* imagePtr = rawImageData)
        {
            // Cast the byte pointer to an RgbaPixel pointer.
            // Each increment now jumps sizeof(RgbaPixel) = 4 bytes forward.
            RgbaPixel* pixelPtr = (RgbaPixel*)imagePtr;

            int pixelCount = rawImageData.Length / sizeof(RgbaPixel);

            for (int i = 0; i < pixelCount; i++)
            {
                // Dereference the pointer — reads 4 bytes as one struct, zero copying
                RgbaPixel pixel = *(pixelPtr + i);
                Console.WriteLine(
                    $"  Pixel {i}: R={pixel.Red,3} G={pixel.Green,3} " +
                    $"B={pixel.Blue,3} A={pixel.Alpha,3}");
            }
        }
    }

    // ── DEMO 2: Parse a network packet header by reinterpreting bytes ────────
    static unsafe void ParseNetworkPacket()
    {
        // Simulate 4 raw bytes arriving from a socket
        byte[] wireBytes = { 0x01, 0x05, 0x00, 0x2C }; // version=1, type=5, length=44

        Console.WriteLine("\n=== Network Packet Reinterpretation ===");

        fixed (byte* wirePtr = wireBytes)
        {
            PacketHeader* header = (PacketHeader*)wirePtr;

            Console.WriteLine($"  Version:       {header->Version}");
            Console.WriteLine($"  MessageType:   {header->MessageType}");

            // PayloadLength is big-endian on the wire; x86 is little-endian
            // so we must byte-swap it before using the value
            ushort rawLength = header->PayloadLength;
            ushort correctedLength = (ushort)((rawLength << 8) | (rawLength >> 8));
            Console.WriteLine($"  PayloadLength: {correctedLength} bytes (after endian swap)");
        }
    }

    // ── DEMO 3: Unsafe.As — zero-copy reinterpret without raw pointer syntax ─
    static void ReinterpretWithUnsafeClass()
    {
        Console.WriteLine("\n=== Unsafe.As Reinterpretation ===");

        // Read 4 bytes as a little-endian int — same idea, no 'unsafe' keyword needed here
        byte[] fourBytes = { 0x01, 0x00, 0x00, 0x00 }; // little-endian 1

        // Unsafe.As reinterprets the reference, not a copy — this is genuinely zero-cost
        ref byte firstByte = ref fourBytes[0];
        int reinterpretedInt = Unsafe.ReadUnaligned<int>(ref firstByte);
        Console.WriteLine($"  Bytes {{1,0,0,0}} reinterpreted as int = {reinterpretedInt}");

        // Works for any unmanaged type — incredibly useful for binary protocol parsing
        float reinterpretedFloat = Unsafe.ReadUnaligned<float>(ref firstByte);
        Console.WriteLine($"  Same bytes reinterpreted as float = {reinterpretedFloat}");
    }

    static void Main()
    {
        ProcessPixelBuffer();
        ParseNetworkPacket();
        ReinterpretWithUnsafeClass();
    }
}

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

// A self-contained benchmark — no BenchmarkDotNet required.
// Run in Release mode for meaningful numbers: dotnet run -c Release
class UnsafePerformanceComparison
{
    const int BufferSize   = 1_000_000; // 1 MB of bytes
    const int Iterations   = 500;        // repeat to get stable timings

    // ── Approach 1: Classic safe loop with bounds check every iteration ──────
    static long SumSafe(byte[] data)
    {
        long total = 0;
        for (int i = 0; i < data.Length; i++)
            total += data[i]; // runtime emits a bounds check here
        return total;
    }

    // ── Approach 2: Span<T> — bounds-checked but JIT can often hoist check ──
    static long SumSpan(Span<byte> data)
    {
        long total = 0;
        // JIT recognises this pattern and can remove per-iteration bounds checks
        for (int i = 0; i < data.Length; i++)
            total += data[i];
        return total;
    }

    // ── Approach 3: Raw unsafe pointer — zero bounds checks, pure arithmetic ─
    static unsafe long SumUnsafe(byte[] data)
    {
        long total = 0;
        fixed (byte* ptr = data)
        {
            byte* current = ptr;
            byte* end     = ptr + data.Length;

            // Process 8 bytes per iteration to help the CPU pipeline
            while (current + 8 <= end)
            {
                total += *current;     // no bounds check — we're responsible
                total += *(current+1);
                total += *(current+2);
                total += *(current+3);
                total += *(current+4);
                total += *(current+5);
                total += *(current+6);
                total += *(current+7);
                current += 8;
            }
            // Handle any remaining bytes (if BufferSize % 8 != 0)
            while (current < end)
            {
                total += *current++;
            }
        }
        return total;
    }

    // ── Approach 4: Unsafe.Add — pointer arithmetic without unsafe context ───
    static long SumUnsafeClass(byte[] data)
    {
        long total = 0;
        ref byte first = ref MemoryMarshal.GetArrayDataReference(data); // no bounds check path
        for (int i = 0; i < data.Length; i++)
            total += Unsafe.Add(ref first, i); // no per-iteration bounds check
        return total;
    }

    static void Benchmark(string label, Func<long> action)
    {
        // Warm up the JIT — discard first run
        action();

        var sw = Stopwatch.StartNew();
        long result = 0;
        for (int i = 0; i < Iterations; i++)
            result = action();
        sw.Stop();

        Console.WriteLine(
            $"  {label,-22} | Result: {result,14:N0} | Time: {sw.ElapsedMilliseconds,5} ms");
    }

    static void Main()
    {
        byte[] buffer = new byte[BufferSize];
        var rng = new Random(42);
        rng.NextBytes(buffer);

        Console.WriteLine($"Summing {BufferSize:N0} bytes × {Iterations} iterations (Release mode)\n");
        Console.WriteLine($"  {"Approach",-22} | {"Result",14} | Time");
        Console.WriteLine(new string('-', 55));

        Benchmark("Safe array loop",   () => SumSafe(buffer));
        Benchmark("Span<T> loop",      () => SumSpan(buffer));
        Benchmark("Raw unsafe pointer",() => SumUnsafe(buffer));
        Benchmark("Unsafe.Add",        () => SumUnsafeClass(buffer));

        Console.WriteLine("\nNote: Results identical across all approaches — correctness verified.");
    }
}

using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

class ProductionSafeUnsafePatterns
{
    // ── PATTERN 1: Wrong — fixed block spanning an await (WON'T COMPILE) ────
    // Shown as a comment so you understand the error before hitting it yourself
    //
    // static async Task BadAsyncFixed(byte[] data)
    // {
    //     unsafe
    //     {
    //         fixed (byte* ptr = data)   // ERROR CS4013 — 'fixed' and 'await' incompatible
    //         {
    //             await Task.Delay(100); // ← the await is the problem
    //             Console.WriteLine(*ptr);
    //         }
    //     }
    // }

    // ── PATTERN 2: Correct — unsafe work in synchronous helper, called async ─
    static unsafe int ProcessBufferSync(byte[] data, int expectedLength)
    {
        // Always validate BEFORE touching a pointer — treat length as a contract
        if (data == null)            throw new ArgumentNullException(nameof(data));
        if (data.Length < expectedLength)
            throw new ArgumentException(
                $"Buffer too small: expected {expectedLength}, got {data.Length}",
                nameof(data));

        int checksum = 0;
        fixed (byte* ptr = data)
        {
            // Inner loop is purely synchronous — no async machinery in sight
            for (int i = 0; i < expectedLength; i++)
                checksum ^= *(ptr + i); // XOR checksum — simple example of pointer walk
        }
        return checksum;
    }

    static async Task<int> ProcessBufferAsync(byte[] data)
    {
        // Do async I/O (or whatever async work) outside the unsafe block
        await Task.Yield(); // simulates async scheduling

        // Then call the synchronous unsafe helper — clean separation
        return ProcessBufferSync(data, data.Length);
    }

    // ── PATTERN 3: GCHandle for long-lived pins (e.g., passing to native lib) ─
    static void LongLivedPinExample()
    {
        byte[] sharedBuffer = new byte[1024];
        new Random(0).NextBytes(sharedBuffer);

        GCHandle pinnedHandle = default;
        try
        {
            // Pin the buffer — GC will never move it until we call Free()
            pinnedHandle = GCHandle.Alloc(sharedBuffer, GCHandleType.Pinned);
            IntPtr rawAddress = pinnedHandle.AddrOfPinnedObject();

            Console.WriteLine($"Buffer pinned at: 0x{rawAddress.ToInt64():X}");
            Console.WriteLine($"First byte via GCHandle: {Marshal.ReadByte(rawAddress)}");

            // In real code you'd pass rawAddress to a P/Invoke call here,
            // and the native library would write directly into sharedBuffer.
            // The handle keeps the buffer stable for the entire native call duration.
        }
        finally
        {
            // ALWAYS free in finally — a leaked Pinned GCHandle is permanent heap damage
            if (pinnedHandle.IsAllocated)
            {
                pinnedHandle.Free();
                Console.WriteLine("GCHandle freed — GC can compact buffer again.");
            }
        }
    }

    // ── PATTERN 4: Wrapping unsafe in a safe public API ─────────────────────
    // External callers never see the unsafe internals — this is the golden pattern
    public static int ComputeXorChecksum(ReadOnlySpan<byte> data)
    {
        if (data.IsEmpty) return 0;

        // Span gives us a ref to the first element — no fixed needed, no heap allocation
        unsafe
        {
            fixed (byte* ptr = data) // fixed works on Span<T> too
            {
                int result = 0;
                for (int i = 0; i < data.Length; i++)
                    result ^= *(ptr + i);
                return result;
            }
        }
    }

    static async Task Main()
    {
        byte[] testData = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };

        int asyncResult = await ProcessBufferAsync(testData);
        Console.WriteLine($"\nAsync XOR checksum: 0x{asyncResult:X2}");

        LongLivedPinExample();

        int spanResult = ComputeXorChecksum(testData);
        Console.WriteLine($"Span-based checksum: 0x{spanResult:X2}");
    }
}