Le moyen le plus rapide de convertir int à 4 octets en C #

Un octet* fonte en utilisant le code unsafe est de loin la plus rapide:

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

C'est ce que BitConverter n'ainsi, ce code permet d'éviter le coût de la création du tableau.

J'ai fait une recherche sur le temps nécessaire pour sérialiser un type de base de tableau d'octets. Je l'ai fait pour le cas où vous disposez déjà d'un tableau et de l'offset où vous voulez mettre vos données. Je suppose que c'est vraiment une affaire importante par rapport à la théorie de l'obtenir un tableau de 4 octets parce que quand vous êtes à la sérialisation de quelque chose, alors c'est exactement ce dont vous avez besoin. J'ai compris que la réponse à quelle méthode est plus rapide dépend de ce que vous voulez de sérialiser. J'ai essayé quelques méthodes:

1. Dangereux de référence avec un supplément de dépassement de la mémoire tampon de vérifier
2. GetBytes + conséquente de la mémoire Tampon.BulkCopy (Ce qui est essentiellement le même que le 1, plus les frais généraux)
3. Affectation directe avec la touche shift (
   m_Bytes[offset] = (byte)(value >> 8)
4. Affectation directe avec la touche shift et bit-à-bit &
   m_Bytes[offset] = (byte)((i >> 8) & 0xFF)

J'ai couru tous les test de 10 millions de fois. Ci-dessous sont les résultats en millisecondes

 Long Int Court 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 14 29 

Comme vous pouvez le voir le dangereux chemin est beaucoup plus rapide pour une longue et double (unsigned versions sont environ les mêmes que les versions signées de sorte qu'ils ne sont pas dans le tableau). Pour faire court/int/float le moyen le plus rapide est le 2/4/4 affectations avec la touche shift. Pour l'octet le plus rapide est évidemment la simple affectation. Donc en ce qui concerne la question de départ, - l'affectation est le meilleur. C'est l'exemple d'une telle fonction dans une manière la plus rapide:

    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. Les tests ont été exécutés sur x64 environnement avec le code compilé pour cpu tout (ce qui était x64 sur exécuter) en mode release.

Note le BitConverter peut-être pas la plus rapide dans le test ci-dessous.

Utiliser le BitConverter classe, plus précisément le GetBytes méthode qui prend un Int32 paramètre:

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

Vous pouvez utiliser BitConverter.IsLittlEndian pour déterminer l'ordre des octets basé sur l'architecture du PROCESSEUR.

EDIT: Le test ci-dessous n'est pas concluante en raison optimisations du compilateur.

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

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

En moyenne autour de 2770ms sur ma machine alors que

[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();
}
}

En moyenne autour de 4510ms.