Най-бързият начин за четене и писане на двоичен код

Важно: ако имате нужда само от one endian, вижте магията на указателя от wj32 / dtb

Лично аз бих писал директно в Stream (може би с известно буфериране) и бих използвал повторно споделен буфер, който като цяло мога да приема, че е чист. След това можете да направите някои преки пътища и да приемете индекс 0/1/2/3.

Със сигурност не използвайте BitConverter, тъй като това не може да се използва както за little/big-endian, което ви е необходимо. Също така бих бил склонен просто да използвам bit-shifting, а не unsafe и т.н. Всъщност е най-бързият въз основа на следното (така че се радвам, че това е начинът, по който вече го правя моя код тук, потърсете EncodeInt32Fixed):

Set1: 371ms
Set2: 171ms
Set3: 993ms
Set4: 91ms <==== bit-shifting ;-p

код:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
static class Program
{
    static void Main()
    {
        const int LOOP = 10000000, INDEX = 100, VALUE = 512;
        byte[] buffer = new byte[1024];
        Stopwatch watch;

        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            Set1(buffer, INDEX, VALUE);
        }
        watch.Stop();
        Console.WriteLine("Set1: " + watch.ElapsedMilliseconds + "ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            Set2(buffer, INDEX, VALUE);
        }
        watch.Stop();
        Console.WriteLine("Set2: " + watch.ElapsedMilliseconds + "ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            Set3(buffer, INDEX, VALUE);
        }
        watch.Stop();
        Console.WriteLine("Set3: " + watch.ElapsedMilliseconds + "ms");

        watch = Stopwatch.StartNew();
        for (int i = 0; i < LOOP; i++)
        {
            Set4(buffer, INDEX, VALUE);
        }
        watch.Stop();
        Console.WriteLine("Set4: " + watch.ElapsedMilliseconds + "ms");

        Console.WriteLine("done");
        Console.ReadLine();
    }
    unsafe static void Set1(byte[] target, int index, int value)
    {
        fixed (byte* p = &target[0])
        {
            Marshal.WriteInt32(new IntPtr(p), index, value);
        }
    }

    unsafe static void Set2(byte[] target, int index, int value)
    {
        int* p = &value;
        for (int i = 0; i < 4; i++)
        {
            target[index + i] = *((byte*)p + i);
        }
    }

    static void Set3(byte[] target, int index, int value)
    {
        byte[] data = BitConverter.GetBytes(value);
        Buffer.BlockCopy(data, 0, target, index, data.Length);
    }
    static void Set4(byte[] target, int index, int value)
    {
        target[index++] = (byte)value;
        target[index++] = (byte)(value >> 8);
        target[index++] = (byte)(value >> 16);
        target[index] = (byte)(value >> 24);
    }
}

Използвайки Set1 до Set4 на Marc Gravell и Set5 по-долу, получавам следните числа на моята машина:

Set1: 197ms
Set2: 102ms
Set3: 604ms
Set4: 68ms
Set5: 55ms <==== pointer magic ;-p

Код:

unsafe static void Set5(byte[] target, int index, int value)
{
    fixed (byte* p = &target[index])
    {
        *((int*)p) = value;                
    }
}

Разбира се, става много по-бързо, когато масивът от байтове не е фиксиран на всяка итерация, а само веднъж:

Set6: 10ms (little endian)
Set7: 85ms (big endian)

Код:

if (!BitConverter.IsLittleEndian)
{
    throw new NotSupportedException();
}

watch = Stopwatch.StartNew();
fixed (byte* p = buffer)
{
    for (int i = 0; i < LOOP; i++)
    {
        *((int*)(p + INDEX)) = VALUE;
    }
}
watch.Stop();
Console.WriteLine("Set6: " + watch.ElapsedMilliseconds + "ms");

watch = Stopwatch.StartNew();
fixed (byte* p = buffer)
{
    for (int i = 0; i < LOOP; i++)
    {
        *((int*)(p + INDEX)) = System.Net.IPAddress.HostToNetworkOrder(VALUE);
    }
}
watch.Stop();
Console.WriteLine("Set7: " + watch.ElapsedMilliseconds + "ms");

Указателите са пътят. Закрепването на обекти с ключовата дума fixed е изключително евтино и избягвате излишните разходи за извикване на функции като WriteInt32 и BlockCopy. За „общо решение“ можете просто да използвате void* и да използвате свой собствен memcpy (тъй като имате работа с малки количества данни). Указателите обаче не работят с истински генерични продукти.

Трябва да направите известно профилиране на вашия код, за да разкриете дали това е тясното място. Освен това, гледайки кода ви, изглежда, че използвате извиквания на функция .Net, за да запишете един байт в неуправляван масив, включвайки пин на паметта и извикване на опасен код...

Може да е много по-добре да декларирате .Net System.IO.MemoryStream и да търсите и пишете около него, където е възможно да използвате записващ поток, за да накарате вашите промени, което трябва да използва по-малко извиквания на функции и няма да изисква опасен код. Ще откриете, че нещата с указателя са много по-полезни в C#, ако правите неща като DSP, където трябва да извършите една операция към всяка стойност в масив и т.н.

РЕДАКТИРАНЕ: Позволете ми също да спомена, че в зависимост от това, което правите, може да откриете, че кеширането на процесора ще влезе в сила, ако можете да продължите да работите върху една малка област от паметта, която се побира в кеша, тогава ще получите най-доброто производителност.