C# Copia le variabili nel buffer senza creare garbage?

Question

E 'possibile in C# .Net (3.5 e versioni successive) copiare una variabile in un buffer byte [] senza creare alcuna spazzatura nel processo?

Ad esempio:

int variableToCopy = 9861; 

byte[] buffer = new byte[1024]; 
byte[] bytes = BitConverter.GetBytes(variableToCopy); 
Buffer.BlockCopy(bytes, 0, buffer, 0, 4); 

float anotherVariableToCopy = 6743897.6377f; 
bytes = BitConverter.GetBytes(anotherVariableToCopy); 
Buffer.BlockCopy(bytes, 0, buffer, 4, sizeof(float)); 

... 

crea l'oggetto intermedio byte [] bytes che diventa spazzatura (presumendo un ref non è più tenuto ad esso) ...

Chissà se utilizzando operatori bit per bit i la variabile può essere copiata direttamente nel buffer senza creare il byte intermedio []?

Answer 1

Utilizzare i puntatori è il migliore e il modo più veloce: Si può fai questo con un numero qualsiasi di variabili, non c'è memoria sprecata, l'istruzione fissa ha un piccolo sovraccarico ma è troppo piccola

 int v1 = 123; 
     float v2 = 253F; 
     byte[] buffer = new byte[1024]; 
     fixed (byte* pbuffer = buffer) 
     { 
      //v1 is stored on the first 4 bytes of the buffer: 
      byte* scan = pbuffer; 
      *(int*)(scan) = v1; 
      scan += 4; //4 bytes per int 

      //v2 is stored on the second 4 bytes of the buffer: 
      *(float*)(scan) = v2; 
      scan += 4; //4 bytes per float 
     } 

Answer 2

Perché non puoi semplicemente fare:

byte[] buffer = BitConverter.GetBytes(variableToCopy); 

Si noti che la matrice qui non è un riferimento indiretto al deposito per l'originale Int32, è molto più di una copia.

Si sono forse preoccupati che bytes nel tuo esempio è equivalente a:

unsafe 
{ 
    byte* bytes = (byte*) &variableToCopy; 
} 

.. ma vi assicuro che non lo è; è una copia byte per byte dei byte nella sorgente Int32.

EDIT:

base alla tua modifica, penso che si desidera qualcosa di simile (richiede contesto non sicuro):

public unsafe static void CopyBytes(int value, byte[] destination, int offset) 
{ 
    if (destination == null) 
     throw new ArgumentNullException("destination"); 

    if (offset < 0 || (offset + sizeof(int) > destination.Length)) 
     throw new ArgumentOutOfRangeException("offset"); 

    fixed (byte* ptrToStart = destination) 
    { 
     *(int*)(ptrToStart + offset) = value; 
    } 
}