BigInteger.ToByteArray Methode

Definition

Namespace:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Überlädt

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.

ToByteArray()

Quelle:

BigInteger.cs

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 Bytes im Array, das von dieser Methode zurückgegeben wird, werden in little-endian-Reihenfolge angezeigt. Das heißt, die Bytes der niedrigeren Reihenfolge des Werts gehen den Bytes höherer Ordnung voran. Das erste Byte des Arrays spiegelt die ersten acht Bits des BigInteger Werts wider, das zweite Byte die nächsten acht Bits usw. Beispielsweise wird der Wert 1024 oder 0x0400 als das folgende Array von zwei Bytes gespeichert:

Element	Bytewert
0	0x00
1	0x04

Negative Werte werden mithilfe der Komplementdarstellung von zwei in möglichst kompakter Form in das Array geschrieben. Beispielsweise wird -1 als einzelnes Byte dargestellt, dessen Wert 0xFF anstelle von als Array mit mehreren Elementen 0xFFwie , 0xFF oder 0xFF, 0xFF, 0xFFist 0xFF.

Da die Komplementdarstellung von zwei immer das bit der höchsten Ordnung des letzten Bytes im Array (das Byte an 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 eindeutig zu definieren, die andernfalls so interpretiert werden könnten, dass ihre Vorzeichenbits festgelegt sind. Beispielsweise wird der Wert 120 oder 0x78 als Einbytearray dargestellt: 0x78. 128 oder 0x80wird jedoch als Zwei-Byte-Array dargestellt: 0x80, 0x00.

Sie können einen Roundtrip für einen BigInteger Wert durchführen, indem Sie ihn in einem 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 das Zeichenbit nicht versehentlich ändern. Wenn Ihre Änderungen z. B. einen positiven Wert erhöhen, sodass das Bit der höchsten Ordnung im letzten Element des Bytearrays festgelegt wird, können Sie ein neues Byte hinzufügen, dessen Wert null am Ende des Arrays ist.

ToByteArray(Boolean, Boolean)

Quelle:

BigInteger.cs

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

OverflowException

Wenn isUnsignedtrue und Sign negativ ist.

Hinweise

Der ganzzahlige Wert 33022 kann in vier verschiedene 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 }