Est-il un moyen moins douloureux à GetBytes pour un tampon non à partir de 0?

Question

Je suis d'avoir à traiter avec des octets premières dans un projet et je dois faire quelque chose comme ceci essentiellement

byte[] ToBytes(){
  byte[] buffer=new byte[somelength];
  byte[] tmp;
  tmp=BitConverter.GetBytes(SomeShort);
  buffer[0]=tmp[0];
  buffer[1]=tmp[1];
  tmp=BitConverter.GetBytes(SomeOtherShort);
  buffer[2]=tmp[0];
  buffer[3]=tmp[1];
}

Je me sens comme cela est si mal mais je ne peux pas trouver une meilleure façon de le faire. Y at-il un moyen plus facile?

Answer 1

BinaryWriter est très efficace:

    byte[] ToBytes() {
        var ms = new MemoryStream(somelength);
        var bw = new BinaryWriter(ms);
        bw.Write(SomeShort);
        bw.Write(SomeOtherShort);
        return ms.ToArray();
    }

Answer 2

Vous n'avez pas besoin d'initialiser tmp à un nouveau tableau. BitConverter.GetBytes crée un nouveau tableau et il retourne pour vous. Il n'y a pas beaucoup que vous pouvez faire GetBytes mais vous pouvez utiliser des méthodes telles que Buffer.BlockCopy pour simplifier l'opération de copie.

Si vous ne faites pas cela dans une performance critique morceau de code, vous pouvez aller un peu LINQy et faire des choses comme:

IEnumerable<byte> bytes = BitConverter.GetBytes(first);
bytes = bytes.Concat(BitConverter.GetBytes(second));
bytes = bytes.Concat(BitConverter.GetBytes(third));
// ... so on; you can chain the calls too
return bytes.ToArray();

Answer 3

Si vous connaissez la taille au préalable (un ensemble de types de valeur), vous pouvez utiliser une struct et affecter vos valeurs dans le struct. Ensuite, utilisez le code unsafe pour copier les octets bruts. Je reste déconseiller à moins qu'il est vraiment nécessaire à des fins de vitesse. Et vous pourriez penser qu'il est douloureux:)

private struct MyStruct
{
    public short A;
    public short B;

    public MyStruct(short a, short b)
    {
        A = a;
        B = b;
    }
}

private unsafe byte[] UnsafeStruct(MyStruct myStruct)
{
    byte[] buffer = new byte[4]; // where 4 is the size of the struct
    fixed (byte* ptr = buffer)
    {
        *((MyStruct*)ptr) = myStruct;
    }
    return buffer;
}

Answer 4

Juste peu de décalage ...

buffer[0]=(byte)SomeShort;
buffer[1]=(byte)(SomeShort >> 8);
buffer[2]=(byte)SomeOtherShort;
buffer[3]=(byte)(SomeOtherShort >> 8);

Cela signifie également que vous êtes dans le contrôle complet de la endian-ness (dans ce cas, petit-boutiste)

Answer 5

Vous pouvez rendre votre code un peu plus court en utilisant Array.Copy, mais non il n'y a pas de surcharge GetBytes ou l'équivalent en BitConverter qui met les octets directement dans votre tampon.

Peut-être BinaryWriter sur < a href = "http://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx" rel = "nofollow noreferrer"> MemoryStream est ce que vous voulez?

Notez que, en adoptant les conventions de l'API de BitConverter que vous n'aimez pas, vous causez le même problème pour les utilisateurs de votre classe. Au lieu de cela, écrire une méthode qui accepte un BinaryWriter et sérialise votre classe en elle, cela s'étend bien quand votre classe est intégré dans un autre objet.