BigInteger.ToByteArray Methode

Definition

Namespace:

System.Numerics

Assembly:

System.Numerics.dll

Überlädt

Name	Beschreibung
ToByteArray()	Konvertiert einen BigInteger Wert in ein Bytearray.

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 BigInteger Objekts, das in ein Bytearray konvertiert wurde.

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

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 von dieser Methode zurückgegebenen Array werden in kleiner endischer Reihenfolge angezeigt. Das heißt, die Bytes der niedrigeren Reihenfolge des Werts stellen die Bytes höherer Reihenfolge voraus. Das erste Byte des Arrays spiegelt die ersten acht Bits des BigInteger Werts wider, das zweite Byte spiegelt die nächsten acht Bits wider 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 der kompaktsten Form möglich in das Array geschrieben. Beispielsweise wird -1 als einzelnes Byte dargestellt, dessen Wert 0xFF anstelle eines Arrays mit mehreren Elementen, z0xFF. B. , 0xFF oder 0xFF0xFF, , 0xFF. 0xFF.

Da zwei Ergänzungsdarstellungen immer das Bit der höchsten 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 mehrdeutige positive Werte zu disambiguieren, die andernfalls als festgelegte Zeichenbits interpretiert werden können. Beispielsweise wird der Wert 120 oder 0x78 als Single-Byte-Array dargestellt: 0x78. 128 oder 0x80, wird jedoch als Zwei-Byte-Array dargestellt: 0x80, 0x00.

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

Vorsicht

Wenn Ihr Code den Wert einzelner Bytes im Array ändert, das von dieser Methode zurückgegeben wird, bevor er den Wert wiederhergestellt, 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.