C # int zu Byte []

Brauche ich zum konvertieren einer int zu einem byte[] einen Weg, es zu tun, ist die Verwendung BitConverter.GetBytes(). Aber ich bin nicht sicher, ob das entspricht der folgenden Spezifikation:

Einem XDR-Ganzzahl mit Vorzeichen 32-bit datum, dass für eine ganze Zahl im
der Bereich [-2147483648,2147483647]. Die ganze Zahl ist dargestellt in
Zweierkomplement-notation. Die meisten und am wenigsten signifikanten bytes
0 und 3, beziehungsweise. Ganzzahlen werden wie folgt deklariert:

Quelle: RFC1014 3.2

Wie könnte ich einen int zu byte-transformation, das würde genügen die oben genannte Spezifikation?

InformationsquelleAutor der Frage Peter | 2009-08-23

  1. 177

    RFC ist nur ein Versuch zu sagen, dass eine Ganzzahl ist ein normaler 4-byte-integer mit der Byte bestellt, die in einem big-endian-Weise.

    Nun, Sie sind wahrscheinlich zu arbeiten auf einer little-endian-Maschine und BitConverter.GetBytes() geben Sie die byte[] Umgekehrt. So könnte man versuchen:

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

    Für den code, der die meisten tragbar, aber Sie können es so machen:

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

    InformationsquelleAutor der Antwort paracycle

  2. 30

    Hier ist ein weiterer Weg, es zu tun: wie wir alle wissen, 1x byte = 8x bits und auch eine "normale" integer (int32) enthält 32 bits (4 bytes). Wir können die >> operator shift bits rechts (>> operator ändert nicht Wert.)

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

    InformationsquelleAutor der Antwort Maciek

  3. 19

    BitConverter.GetBytes(int) fast tut, was Sie will, außer die endianness ist falsch.

    Können Sie die IP-Adresse.HostToNetwork Methode zum vertauschen von bytes, die in den integer-Wert vor der Verwendung BitConverter.GetBytes oder verwenden Jon Skeet ist EndianBitConverter Klasse. Beide Methoden tun das richtige(tm) in Bezug auf Portabilität.

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

    InformationsquelleAutor der Antwort dtb

  4. 3

    Wenn ich mir diese Beschreibung habe ich das Gefühl, dass diese xdr integer ist nur ein big-endian "standard" integer, aber es ist ausgedrückt in den meisten verschleierte Art und Weise. Zweierkomplement-notation ist besser bekannt als U2, und es ist, was wir mit heutigen Prozessoren. Die byte-Reihenfolge gibt an, dass es ein big-endian notation.

    Also, um deine Frage zu beantworten, sollten Sie die inversen Elemente in Ihrem array (0 <--> 3, 1 <-->2), wie Sie codiert werden, die in little-endian. Nur um sicherzugehen, sollten Sie zunächst überprüfen BitConverter.IsLittleEndian zu sehen, auf welchen Maschinen Sie ausgeführt werden.

    InformationsquelleAutor der Antwort Marcin Deptuła

  5. 2

    Wenn Sie mehr Allgemeine Informationen über die verschiedenen Methoden zur Darstellung von Zahlenwerten, einschließlich Zweierkomplement haben einen Blick auf:

    Zweierkomplement und Unterzeichnet Zahlendarstellung auf Wikipedia

    InformationsquelleAutor der Antwort Eric J.

  6. 0

    Warum dieser code in den Beispielen oben...

    Einen struct mit expliziten layout wirkt in beide Richtungen und hat keine Leistungseinbußen.

    Update: Da gibt es eine Frage, wie man mit endianness ich fügte hinzu, eine Schnittstelle, die zeigt, wie Abstrakt. Eine andere Implementierung struct kann sich mit den entgegengesetzten Fall,

    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 => b0;
    public byte B2 => b0;
    public byte B3 => b0; 
}

    InformationsquelleAutor der Antwort Sten Petrov

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

    InformationsquelleAutor der Antwort Valery Rode

Schreibe einen Kommentar