Schnellste Weg, um konvertieren von int, 4 bytes in C#

Ein-byte* Guss mit unsicherer code ist mit Abstand der Schnellste:

    unsafe static void Main(string[] args) {
        int i = 0x12345678;
        byte* pi = (byte*)&i;
        byte lsb = pi[0];  
        //etc..
    }

Das ist, was BitConverter als auch nicht, dieser code verhindert den Kosten für die Erstellung der Arrays.

InformationsquelleAutor der Antwort Hans Passant

Ich habe getan, Forschung auf die Zeit benötigt, um zu serialisieren eines basic Typ byte-array. Ich habe es für den Fall, wenn Sie bereits über ein array und offset-wo wollen Sie Ihre Daten. Ich denke, das ist wirklich ein wichtiger Fall im Vergleich zu den theoretischen Holen Sie sich ein array mit 4 bytes, weil beim serialisieren etwas, dann ist es genau das, was Sie brauchen. Ich habe herausgefunden, dass die Antwort auf welche Methode schneller ist, hängt davon ab, welche Art Sie serialisieren möchten. Ich habe versucht einige Methoden:

1. Unsicher Referenz mit einem zusätzlichen Pufferüberlauf prüfen
2. GetBytes + konsequente Puffer.BulkCopy (Dies ist im wesentlichen das gleiche wie 1 plus overhead)
3. Direkte Zuweisung mit shift (
   m_Bytes[offset] = (byte)(value >> 8)
4. Direkte Zuweisung mit shift und bitweise &
   m_Bytes[offset] = (byte)((i >> 8) & 0xFF)

Lief ich alle test-10 Mio mal. Unten sind die Ergebnisse in Millisekunden

 Long Int Short Byte Float Double 
1 29 32 31 30 29 34 
2 209 233 220 212 208 228 
3 63 24 13 8 24 44 
4 72 29 14 

Wie Sie sehen können der unsichere Weg ist, viel schneller für long und double (unsigned-Versionen sind ungefähr das gleiche wie Ihre unterschriebene Versionen, so dass Sie sind nicht in der Tabelle). Für short/int/float der Schnellste Weg ist die 2/4/4 Aufgaben mit shift. Für byte, der Schnellste ist natürlich das einfache Zuweisung. Also in Bezug auf die ursprüngliche Frage - die Zuordnung Weg ist der beste. Dies ist das Beispiel einer solchen Funktion in einem Schnellste Weg:

    public static void WriteInt(byte[] buffer, int offset, int value)
    {
        m_BytesInt[offset] = (byte)(value >> 24);
        m_BytesInt[offset + 1] = (byte)(value >> 16);
        m_BytesInt[offset + 2] = (byte)(value >> 8);
        m_BytesInt[offset + 3] = (byte) value;
    }

P. S. Die tests wurden ausgeführt, die auf x64-Umgebung mit code kompiliert, um jede cpu (x64 am laufen) im release-Modus.

InformationsquelleAutor der Antwort Ilya Chernomordik

Hinweis: die BitConverter vielleicht nicht die Schnellste, wie der test unten zeigt.

Verwenden Sie die BitConverter Klasse, speziell die GetBytes - Methode, die einen Int32 parameter:

var myInt = 123;
var bytes = BitConverter.GetBytes(myInt);

Können Sie BitConverter.IsLittlEndianum zu bestimmen, die byte-Reihenfolge, basierend auf der CPU-Architektur.

EDIT: Der test unten ist nicht schlüssig, aufgrund von compiler-Optimierungen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    [StructLayout(LayoutKind.Explicit)]
    struct FooUnion
    {
        [FieldOffset(0)]
        public byte byte0;
        [FieldOffset(1)]
        public byte byte1;
        [FieldOffset(2)]
        public byte byte2;
        [FieldOffset(3)]
        public byte byte3;

        [FieldOffset(0)]
        public int integer;
    }
    class Program
    {
        static void Main(string[] args)
        {
            testUnion();
            testBitConverter();

            Stopwatch Timer = new Stopwatch();

            Timer.Start();
            testUnion();
            Timer.Stop();

            Console.WriteLine(Timer.ElapsedTicks);

            Timer = new Stopwatch();

            Timer.Start();
            testBitConverter();
            Timer.Stop();

            Console.WriteLine(Timer.ElapsedTicks);
            Console.ReadKey();
        }

        static void testBitConverter()
        {
            byte[] UnionBytes;

            for (int i = 0; i < 10000; i++)
            {
                UnionBytes = BitConverter.GetBytes(i);
            }
        }

        static void testUnion()
        {
            byte[] UnionBytes;

            for (int i = 0; i < 10000; i++)
            {
                FooUnion union = new FooUnion() { integer = i };

                UnionBytes = new byte[] { union.byte0, union.byte1, union.byte2, union.byte3 };

            }
        }
    }
}

InformationsquelleAutor der Antwort George Duckett

class Program
{
    static void Main(string[] args)
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        unsafe{
            byte[] byteArray = new byte[4];
            for(int i = 0; i != int.MaxValue; ++i)
            {
            fixed(byte* asByte = byteArray)
               *((int*)asByte) = 43;
               }
        }
        Console.WriteLine(sw.ElapsedMilliseconds);
        Console.Read();
    }
}

Durchschnittlich rund 2770ms auf meinem Rechner während

[StructLayout(LayoutKind.Explicit)]
struct Switcher
{
  [FieldOffset(0)]
  public int intVal;
  [FieldOffset(0)]
  public byte b0;
  [FieldOffset(1)]
  public byte b1;
  [FieldOffset(2)]
  public byte b2;
  [FieldOffset(3)]
  public byte b3;
}
class Program
{
    static void Main(string[] args)
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        byte[] byteArray = new byte[4];
        Switcher swi = new Switcher();
        for(int i = 0; i != int.MaxValue; ++i)
        {
          swi.intVal = 43;
          byteArray[0] = swi.b0;
          byteArray[1] = swi.b1;
          byteArray[2] = swi.b2;
          byteArray[3] = swi.b3;
        }
        Console.WriteLine(sw.ElapsedMilliseconds);
        Console.Read();
    }
}

Durchschnittlich rund 4510ms.

InformationsquelleAutor der Antwort Jon Hanna