BigInteger.ToByteArray Methode

Definition

Überlädt

ToByteArray(Boolean, Boolean)

Liefert den Wert dieses BigInteger als Bytearray mit der kleinstmöglichen Anzahl von Bytes. Wenn der Wert Null (0) ist, wird ein Array von einem Byte zurückgegeben, dessen Element 0x00 ist.

ToByteArray()

Konvertiert einen BigInteger-Wert in ein Bytearray.

ToByteArray(Boolean, Boolean)

Liefert den Wert dieses BigInteger als Bytearray mit der kleinstmöglichen Anzahl von Bytes. Wenn der Wert Null (0) ist, wird ein Array von einem Byte zurückgegeben, dessen Element 0x00 ist.

public byte[] ToByteArray (bool isUnsigned = false, bool isBigEndian = false);
member this.ToByteArray : bool * bool -> byte[]
Public Function ToByteArray (Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false) As Byte()

Parameter

isUnsigned
Boolean

true, um die Codierung ohne Vorzeichen zu verwenden, andernfalls false.

isBigEndian
Boolean

true, um die Bytes in einer Big-Endian-Bytereihenfolge zu schreiben, andernfalls false.

Gibt zurück

Byte[]

Der Wert des aktuellen, in ein Bytearray konvertierten BigInteger-Objekts.

Ausnahmen

Wenn isUnsignedtrue und Sign negativ ist.

Hinweise

Der ganze Wert 33022 kann in vier verschiedenen Arrays exportiert werden:

Eigenschaften Ergebnis
isUnsigned: false, isBigEndian: false new byte[] { 0xFE, 0x80, 0x00 }
isUnsigned: false, isBigEndian: true new byte[] { 0x00, 0x80, 0xFE }
isUnsigned: true, isBigEndian: false new byte[] { 0xFE, 0x80 }
isUnsigned: true, isBigEndian: true new byte[] { 0x80, 0xFE }

Gilt für:

ToByteArray()

Konvertiert einen BigInteger-Wert in ein Bytearray.

public:
 cli::array <System::Byte> ^ ToByteArray();
public byte[] ToByteArray ();
member this.ToByteArray : unit -> byte[]
Public Function ToByteArray () As Byte()

Gibt zurück

Byte[]

Der Wert des aktuellen, in ein Bytearray konvertierten BigInteger-Objekts.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie einige BigInteger Werte in Bytearrays dargestellt werden.

using System;
using System.Numerics;

public class Example
{
   static byte[] bytes;

   public static void Main()
   {
      BigInteger[] numbers = { BigInteger.MinusOne, BigInteger.One,
                               BigInteger.Zero, 120, 128, 255, 1024,
                               Int64.MinValue, Int64.MaxValue,
                               BigInteger.Parse("90123123981293054321") };
      foreach (BigInteger number in numbers)
      {
         bytes = number.ToByteArray();
         Console.Write("{0} ({1}) -> ", number, number.ToString(GetSpecifier()));
         Console.Write("{0} bytes: ", bytes.Length);
         foreach (byte byteValue in bytes)
            Console.Write("{0:X2} ", byteValue);

         Console.WriteLine();
      }
   }

   private static string GetSpecifier()
   {
      return "X" + (bytes.Length * 2).ToString();
   }
}
// The example displays the following output:
//    -1 (FF) -> 1 bytes: FF
//    1 (01) -> 1 bytes: 01
//    0 (00) -> 1 bytes: 00
//    120 (78) -> 1 bytes: 78
//    128 (0080) -> 2 bytes: 80 00
//    255 (00FF) -> 2 bytes: FF 00
//    1024 (0400) -> 2 bytes: 00 04
//    -9223372036854775808 (8000000000000000) -> 8 bytes: 00 00 00 00 00 00 00 80
//    9223372036854775807 (7FFFFFFFFFFFFFFF) -> 8 bytes: FF FF FF FF FF FF FF 7F
//    90123123981293054321 (04E2B5A7C4A975E971) -> 9 bytes: 71 E9 75 A9 C4 A7 B5 E2 04
Imports System.Numerics

Module Example
   Dim bytes() As Byte
      
   Public Sub Main()
      Dim numbers() As BigInteger = { BigInteger.MinusOne, BigInteger.One, 
                                      BigInteger.Zero, 120, 128, 255, 1024, 
                                      Int64.MinValue, Int64.MaxValue, 
                                      BigInteger.Parse("90123123981293054321") }
      For Each number As BigInteger In numbers
         bytes = number.ToByteArray()
         Console.Write("{0} ({1}) -> ", number, number.ToString(GetSpecifier()))
         Console.Write("{0} bytes: ", bytes.Length)
         For Each byteValue As Byte In bytes
            Console.Write("{0:X2} ", byteValue)
         Next
         Console.WriteLine()
      Next   
   End Sub
   
   Private Function GetSpecifier() As String
      Return "X" + CStr(bytes.Length * 2)
   End Function
End Module
' The example displays the following output:
'    -1 (FF) -> 1 bytes: FF
'    1 (01) -> 1 bytes: 01
'    0 (00) -> 1 bytes: 00
'    120 (78) -> 1 bytes: 78
'    128 (0080) -> 2 bytes: 80 00
'    255 (00FF) -> 2 bytes: FF 00
'    1024 (0400) -> 2 bytes: 00 04
'    -9223372036854775808 (8000000000000000) -> 8 bytes: 00 00 00 00 00 00 00 80
'    9223372036854775807 (7FFFFFFFFFFFFFFF) -> 8 bytes: FF FF FF FF FF FF FF 7F
'    90123123981293054321 (04E2B5A7C4A975E971) -> 9 bytes: 71 E9 75 A9 C4 A7 B5 E2 04

Hinweise

Die einzelnen Byte im Array, das von dieser Methode zurückgegeben wird, werden in kleiner endischer Reihenfolge angezeigt. Das heißt, die unteren Byte der Reihenfolge des Werts vor dem Höherreihenfolgen byte. Der erste Byte des Arrays spiegelt die ersten acht Bit des Werts BigInteger wider, das zweite Byte spiegelt die nächsten acht Bit und so weiter wider. Der Wert 1024 oder 0x0400 wird beispielsweise als folgende Matrix von zwei Bytes gespeichert:

Element Bytewert
0 0x00
1 0x04

Negative Werte werden in das Array geschrieben, indem die Darstellung von zwei Ergänzungen in der kompaktsten Form möglich ist. Beispielsweise wird -1 als einzelnes Byte dargestellt, dessen Wert 0xFF anstelle eines Arrays mit mehreren Elementen, wie z0xFF. B. , 0xFF oder 0xFF``0xFF``0xFF``0xFF, .

Da zwei Ergänzungsdarstellungen immer die höchste Reihenfolge des letzten Bytes im Array (das Byte an der Position Array.Length- 1) als Zeichenbit interpretiert, gibt die Methode ein Bytearray mit einem zusätzlichen Element zurück, dessen Wert null ist, um positive Werte zu disambiguieren, die andernfalls als festgelegte Zeichenbits interpretiert werden könnten. Der Wert 120 oder 0x78 wird beispielsweise als Ein-Byte-Array dargestellt: 0x78 128 oder 0x80, wird jedoch als Zwei-Byte-Array dargestellt: 0x80, 0x00.

Sie können einen BigInteger Wert umrunden, indem Sie ihn in ein Bytearray speichern und dann mithilfe des BigInteger(Byte[]) Konstruktors wiederherstellen.

Achtung

Wenn Ihr Code den Wert einzelner Bytes im Array ändert, das von dieser Methode zurückgegeben wird, bevor der Wert wiederhergestellt wird, müssen Sie sicherstellen, dass Sie den Zeichenbit nicht versehentlich ändern. Wenn Ihre Änderungen z. B. einen positiven Wert erhöhen, damit das höchste Bit im letzten Element des Bytearrays festgelegt wird, können Sie ein neues Byte hinzufügen, dessen Wert null am Ende des Arrays ist.

Gilt für: