C# int to byte []

Question

Necesito convertir un int a un byte[] una forma de hacerlo es usar BitConverter.GetBytes(). Pero im seguro si que coincide con la siguiente especificación:

Un XDR entero de es un dato de 32 bits que codifica un número entero en el rango [-2147483648,2147483647]. El número entero se representa en notación complemento dos. Los bytes más y menos significativos son 0 y 3, respectivamente. Los enteros se declaran los siguientes:

Fuente: RFC1014 3.2

¿Cómo podría hacer un int para la transformación de bytes que satisfaga la especificación anterior?

Answer 1

El RFC solo intenta decir que un entero con signo es un entero normal de 4 bytes con bytes ordenados de una manera big-endian.

Ahora, probablemente esté trabajando en una máquina little-endian y BitConverter.GetBytes() le dará la byte[] invertida. Lo que podría intentar:

int intValue; 
byte[] intBytes = BitConverter.GetBytes(intValue); 
Array.Reverse(intBytes); 
byte[] result = intBytes; 

Para que el código sea más portátil, sin embargo, puede hacerlo de esta manera:

int intValue; 
byte[] intBytes = BitConverter.GetBytes(intValue); 
if (BitConverter.IsLittleEndian) 
    Array.Reverse(intBytes); 
byte[] result = intBytes; 

Answer 2

BitConverter.GetBytes(int) casi hace lo que quiere, sino el orden de bits es incorrecto.

Usted puede utilizar el método IPAddress.HostToNetwork para intercambiar los bytes en el valor entero antes de usar o usar BitConverter.GetBytes Jon Skeet de EndianBitConverter class. Ambos métodos hacen lo correcto (tm) con respecto a la portabilidad.

int value; 
byte[] bytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)); 

Answer 3

Cuando miro esta descripción, tengo la sensación de que este entero XDR es sólo un número entero big endian "estándar", pero ha expresado de la manera más ofuscado. Two's complement notation es mejor conocido como U2, y es lo que estamos usando en los procesadores de hoy. El orden de bytes indica que es una notación big-endian.
Respondiendo a su pregunta, debe invertir los elementos de su matriz (0 < -> 3, 1 < -> 2), ya que están codificados en little-endian. Para asegurarse, primero debe verificar BitConverter.IsLittleEndian para ver en qué máquina se está ejecutando.

Answer 4

Si desea obtener más información general acerca de los diversos métodos de representar números incluyendo complemento a dos echar un vistazo a:

Two's Complement y Signed Number Representation Wikipedia

Answer 5

Ésta es otra manera de hacerlo: como todos sabemos bytes 1x = 8x bits y, además, un entero "normal" (int32) contiene 32 bits (4 bytes). Podemos utilizar el operador >> desplazan los bits a la derecha (>> operador no cambia de valor.)

int intValue = 566; 

byte[] bytes = new byte[4]; 

bytes[0] = (byte)(intValue >> 24); 
bytes[1] = (byte)(intValue >> 16); 
bytes[2] = (byte)(intValue >> 8); 
bytes[3] = (byte)intValue; 

Console.WriteLine("{0} breaks down to : {1} {2} {3} {4}", 
    intValue, bytes[0], bytes[1], bytes[2], bytes[3]); 

Answer 6

byte[] Take_Byte_Arr_From_Int(Int64 Source_Num) 
{ 
    Int64 Int64_Num = Source_Num; 
    byte Byte_Num; 
    byte[] Byte_Arr = new byte[8]; 
    for (int i = 0; i < 8; i++) 
    { 
     if (Source_Num > 255) 
     { 
     Int64_Num = Source_Num/256; 
     Byte_Num = (byte)(Source_Num - Int64_Num * 256); 
     } 
     else 
     { 
     Byte_Num = (byte)Int64_Num; 
     Int64_Num = 0; 
     } 
     Byte_Arr[i] = Byte_Num; 
     Source_Num = Int64_Num; 
    } 
    return (Byte_Arr); 
} 

Answer 7

¿Por qué todo este código en los ejemplos anteriores ...

una estructura con la disposición explícita actúa en ambos sentidos y no tiene ningún impacto en el rendimiento

[StructLayout(LayoutKind.Explicit)] 
struct IntByte 
{ 
    [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; 
}