BigInteger.ToByteArray Methode

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 cli::array <System::Byte> ^ ToByteArray();

public byte[] ToByteArray ();

member this.ToByteArray : unit -> byte[]

Public Function ToByteArray () As Byte()

Gibt zurück

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:

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.

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

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

Gibt zurück

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

Ausnahmen

Hinweise

Der ganzzahlige Wert 33022 kann in vier verschiedene Arrays exportiert werden: