C # int en octet []

J'ai besoin de convertir un inten une byte[]seule façon de le faire est d'utiliser BitConverter.GetBytes(). Mais je ne sais pas si cela correspond à la spécification suivante:

Un entier signé XDR est une donnée 32 bits qui code un entier compris dans la plage [-2147483648,2147483647]. L'entier est représenté dans la notation du complément à deux. Les octets les plus et les moins significatifs sont respectivement 0 et 3. Les entiers sont déclarés comme suit:

La source: RFC1014 3.2

Comment puis-je effectuer une transformation int en octet qui satisferait la spécification ci-dessus?

La RFC essaie simplement de dire qu'un entier signé est un entier normal de 4 octets avec des octets ordonnés de manière big-endian.

Maintenant, vous travaillez très probablement sur une machine little-endian et BitConverter.GetBytes()vous donnerez l' byte[]inverse. Vous pouvez donc essayer:

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

Pour que le code soit le plus portable, cependant, vous pouvez le faire comme ceci:

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

Voici une autre façon de le faire: comme nous le savons tous 1x octet = 8x bits et aussi, un entier "régulier" (int32) contient 32 bits (4 octets). Nous pouvons utiliser l'opérateur >> pour décaler les bits vers la droite (l'opérateur >> ne change pas la valeur.)

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]);

BitConverter.GetBytes(int) fait presque ce que vous voulez, sauf que l'endianisme est faux.

Vous pouvez utiliser la méthode IPAddress.HostToNetwork pour permuter les octets dans la valeur entière avant d'utiliser BitConverter.GetBytesou d'utiliser la classe EndianBitConverter de Jon Skeet . Les deux méthodes font la bonne chose (tm) en ce qui concerne la portabilité.

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

Quand je regarde cette description, j'ai le sentiment que cet entier xdr n'est qu'un entier "standard" big-endian, mais il est exprimé de la manière la plus obscure. La notation du complément de Two est mieux connue sous le nom de U2, et c'est ce que nous utilisons sur les processeurs d'aujourd'hui. L'ordre des octets indique qu'il s'agit d'une notation big-endian .
Donc, pour répondre à votre question, vous devez inverser les éléments de votre tableau (0 <--> 3, 1 <--> 2), car ils sont encodés en petit-boutiste. Juste pour être sûr, vous devez d'abord vérifier BitConverter.IsLittleEndiansur quelle machine vous utilisez.

Pourquoi tout ce code dans les exemples ci-dessus ...

Une structure avec une disposition explicite agit dans les deux sens et n'a aucun impact sur les performances.

Mise à jour: Puisqu'il y a une question sur la façon de gérer l'endianness, j'ai ajouté une interface qui illustre comment résumer cela. Une autre structure d'implémentation peut gérer le cas contraire

public interface IIntToByte
{
    Int32 Int { get; set;}

    byte B0 { get; }
    byte B1 { get; }
    byte B2 { get; }
    byte B3 { get; }
}

[StructLayout(LayoutKind.Explicit)]
public struct IntToByteLE : UserQuery.IIntToByte
{
    [FieldOffset(0)]
    public Int32 IntVal;

    [FieldOffset(0)]
    public byte b0;
    [FieldOffset(1)]
    public byte b1;
    [FieldOffset(2)]
    public byte b2;
    [FieldOffset(3)]
    public byte b3;

    public Int32 Int {
        get{ return IntVal; }
        set{ IntVal = value;}
    }

    public byte B0 => b0;
    public byte B1 => b1;
    public byte B2 => b2;
    public byte B3 => b3; 
}

Si vous souhaitez des informations plus générales sur les différentes méthodes de représentation des nombres, y compris le complément à deux, consultez:

Complément à deux et représentation des nombres signés sur Wikipedia

L'autre façon est d'utiliser BinaryPrimitives comme ceci

byte[] intBytes = BitConverter.GetBytes(123); int actual = BinaryPrimitives.ReadInt32LittleEndian(intBytes);

using static System.Console;

namespace IntToBits
{
    class Program
    {
        static void Main()
        {
            while (true)
            {
                string s = Console.ReadLine();
                Clear();
                uint i;
                bool b = UInt32.TryParse(s, out i);
                if (b) IntPrinter(i);
            }
        }

        static void IntPrinter(uint i)
        {
            int[] iarr = new int [32];
            Write("[");
            for (int j = 0; j < 32; j++)
            {
                uint tmp = i & (uint)Math.Pow(2, j);

                iarr[j] = (int)(tmp >> j);
            }
            for (int j = 32; j > 0; j--)
            {
                if(j%8==0 && j != 32)Write("|");
                if(j%4==0 && j%8 !=0) Write("'");
                Write(iarr[j-1]);
            }
            WriteLine("]");
        }
    }
}```

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