C # int do bajtu []

Muszę przekonwertować plik intna byte[]jeden ze sposobów, aby to zrobić BitConverter.GetBytes(). Ale nie jestem pewien, czy pasuje do następującej specyfikacji:

Liczba całkowita ze znakiem XDR to 32-bitowe dane, które kodują liczbę całkowitą z zakresu [-2147483648,2147483647]. Liczba całkowita jest reprezentowana w notacji z dopełnieniem do dwóch. Najbardziej i najmniej znaczące bajty to odpowiednio 0 i 3. Liczby całkowite są deklarowane w następujący sposób:

Źródło: RFC1014 3.2

Jak mogę dokonać transformacji int na bajt, która spełniłaby powyższą specyfikację?

RFC próbuje po prostu powiedzieć, że liczba całkowita ze znakiem jest zwykłą 4-bajtową liczbą całkowitą z bajtami uporządkowanymi w sposób big-endian.

Teraz najprawdopodobniej pracujesz na maszynie little-endian i BitConverter.GetBytes()dasz ci byte[]odwrotność. Możesz więc spróbować:

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

Aby kod był najbardziej przenośny, możesz to zrobić w następujący sposób:

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

Oto inny sposób, aby to zrobić: jak wszyscy wiemy, 1x bajt = 8x bitów, a także „zwykła” liczba całkowita (int32) zawiera 32 bity (4 bajty). Możemy użyć operatora >>, aby przesunąć bity w prawo (operator >> nie zmienia wartości).

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) prawie robi, co chcesz, z wyjątkiem tego, że endianness jest zły.

Możesz użyć metody IPAddress.HostToNetwork , aby zamienić bajty w wartości całkowitej przed użyciem BitConverter.GetByteslub użyciem klasy EndianBitConverter Jona Skeeta . Obie metody są słuszne (tm) w zakresie przenośności.

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

Kiedy patrzę na ten opis, mam wrażenie, że ta liczba całkowita xdr jest po prostu „standardową” liczbą całkowitą typu big-endian, ale jest wyrażona w najbardziej zaciemniony sposób. Notacja dopełniająca do dwóch jest lepiej znana jako U2 i właśnie tego używamy na dzisiejszych procesorach. Kolejność bajtów wskazuje, że jest to notacja big-endian .
Odpowiadając więc na twoje pytanie, powinieneś odwrócić elementy w swojej tablicy (0 <--> 3, 1 <--> 2), ponieważ są one zakodowane w little-endian. Aby się upewnić, najpierw sprawdź, BitConverter.IsLittleEndianna jakiej maszynie używasz.

Dlaczego cały ten kod w przykładach powyżej ...

Struktura z jawnym układem działa w obie strony i nie ma wpływu na wydajność.

Aktualizacja: Ponieważ pojawia się pytanie, jak radzić sobie z endianizmem, dodałem interfejs, który ilustruje, jak to ująć. Inna struktura implementująca może zająć się odwrotnym przypadkiem

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

Jeśli chcesz uzyskać więcej ogólnych informacji na temat różnych metod przedstawiania liczb, w tym dopełnienia do dwóch, spójrz na:

Uzupełnienie do dwóch i podpisana reprezentacja numeru w Wikipedii

Innym sposobem jest użycie BinaryPrimitives w ten sposób

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