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

Das folgende Beispiel 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

open System
open System.Numerics

let numbers =
    [| BigInteger.MinusOne
       BigInteger.One
       BigInteger.Zero
       120
       128
       255
       1024
       Int64.MinValue
       Int64.MaxValue
       BigInteger.Parse("90123123981293054321") |]

for number in numbers do
    let bytes = number.ToByteArray()
    printf $"""{number} ({number.ToString("X" + (bytes.Length * 2).ToString())}) -> """
    printf $"{bytes.Length} bytes: "

    for byteValue in bytes do
        printf $"{byteValue:X2} "

    printfn ""

// 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, die von dieser Methode zurückgegeben werden, werden in little-endian-Reihenfolge angezeigt. Das heißt, die Bytes der niedrigeren Reihenfolge des Werts gehen den Bytes höherer Reihenfolge 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 eines Arrays mit mehreren Elementen ist, z0xFF. B. oder 0xFF0xFF, 0xFF, 0xFF0xFF, .

Da die Komplementdarstellung von zwei immer das Bit der höchsten Reihenfolge des letzten Byte im Array (das Byte an Array.Length- 1position ) 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 Einzelbytearray dargestellt: 0x78. 128 oder 0x80wird jedoch als Zwei-Byte-Array dargestellt: 0x80, 0x00.

Sie können einen BigInteger Wert roundtripen, indem Sie ihn in einem Bytearray speichern und ihn 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 unbeabsichtigt ändern. Wenn Ihre Änderungen beispielsweise einen positiven Wert erhöhen, sodass das Bit der höchsten Reihenfolge 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 }