Int matriz de bytes a

Question

pensé .net tenido algún tipo de método de conversión fácil de usar para convertir un entero en una matriz de bytes? Hice una búsqueda rápida y todas las soluciones son un poco máscaras/cambios de un byte a la vez, como "los buenos días". ¿No hay un método ToByteArray() en alguna parte?

Answer 1

byte[] bytes = BitConverter.GetBytes(i); 

aunque también se nota que usted puede ser que desee comprobar BitConverter.IsLittleEndian para ver qué forma de evitar eso va a aparecer!

Tenga en cuenta que si usted está haciendo esto en repetidas ocasiones es posible que desee evitar todas esas asignaciones de matriz de corta vida escribiendo usted mismo, ya sea a través de operaciones de desplazamiento (>>/<<), o mediante el uso unsafe código. Las operaciones de desplazamiento también tienen la ventaja de que no se ven afectadas por orden de bits de su plataforma; usted siempre obtenga los bytes en el orden en que los espera.

Answer 2

la respuesta de Marc es por supuesto la respuesta correcta. Pero desde que mencionó los operadores de turno y el código inseguro como una alternativa. Me gustaría compartir una alternativa menos común. Usar una estructura con diseño Explicit. Esto es similar en principio a C/C++ union.

Aquí hay un ejemplo de una estructura que se puede utilizar para llegar a los bytes componentes del tipo de datos Int32 y lo bueno es que es bidireccional, puede manipular los valores de bytes y ver el efecto en el Int. .

using System.Runtime.InteropServices; 

    [StructLayout(LayoutKind.Explicit)] 
    struct Int32Converter 
    { 
    [FieldOffset(0)] public int Value; 
    [FieldOffset(0)] public byte Byte1; 
    [FieldOffset(1)] public byte Byte2; 
    [FieldOffset(2)] public byte Byte3; 
    [FieldOffset(3)] public byte Byte4; 

    public Int32Converter(int value) 
    { 
     Byte1 = Byte2 = Byte3 = Byte4 = 0; 
     Value = value; 
    } 

    public static implicit operator Int32(Int32Converter value) 
    { 
     return value.Value; 
    } 

    public static implicit operator Int32Converter(int value) 
    { 
     return new Int32Converter(value); 
    } 
    } 

Lo anterior ahora se puede utilizar como sigue

Int32Converter i32 = 256; 
Console.WriteLine(i32.Byte1); 
Console.WriteLine(i32.Byte2); 
Console.WriteLine(i32.Byte3); 
Console.WriteLine(i32.Byte4); 

i32.Byte2 = 2; 
Console.WriteLine(i32.Value); 

Por supuesto la policía inmutabilidad pueden no estar entusiasmado con la última posibilidad :)

Answer 3

Esto puede ser OT pero si usted está serializando una gran cantidad de tipos primitivos o estructuras POD, Google Protocol Buffers for .Net pueden serle útiles. Esto aborda el problema de endianness @Marc mencionado anteriormente, entre otras características útiles.

Answer 4

La mayoría de las respuestas aquí son o bien 'inseguros" o no segura LittleEndian. BitConverter no es LittleEndian seguro. lo tanto sobre la base de un ejemplo en el here (ver el mensaje por PZahra) hice una versión segura LittleEndian simplemente mediante la lectura de la matriz de bytes a la inversa cuando == BitConverter.IsLittleEndian cierto

void Main(){  
    Console.WriteLine(BitConverter.IsLittleEndian); 
    byte[] bytes = BitConverter.GetBytes(0xdcbaabcdfffe1608); 
    //Console.WriteLine(bytes); 
    string hexStr = ByteArrayToHex(bytes); 
    Console.WriteLine(hexStr); 
} 

public static string ByteArrayToHex(byte[] data) 
{ 
    char[] c = new char[data.Length * 2]; 
    byte b; 
    if(BitConverter.IsLittleEndian) 
    { 
     //read the byte array in reverse 
     for (int y = data.Length -1, x = 0; y >= 0; --y, ++x) 
     { 
      b = ((byte)(data[y] >> 4)); 
      c[x] = (char)(b > 9 ? b + 0x37 : b + 0x30); 
      b = ((byte)(data[y] & 0xF)); 
      c[++x] = (char)(b > 9 ? b + 0x37 : b + 0x30); 
     }    
    } 
    else 
    { 
     for (int y = 0, x = 0; y < data.Length; ++y, ++x) 
     { 
      b = ((byte)(data[y] >> 4)); 
      c[x] = (char)(b > 9 ? b + 0x37 : b + 0x30); 
      b = ((byte)(data[y] & 0xF)); 
      c[++x] = (char)(b > 9 ? b + 0x37 : b + 0x30); 
     } 
    } 
    return String.Concat("0x",new string(c)); 
} 

devuelve la siguiente:.

True 
0xDCBAABCDFFFE1608 

que es el hexadecimal exacto en que entró en la matriz de bytes