BigInteger.ToByteArray BigInteger.ToByteArray BigInteger.ToByteArray BigInteger.ToByteArray Method

Definition

Überlädt

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

Konvertiert einen BigInteger-Wert in ein Bytearray.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

Konvertiert einen BigInteger-Wert in ein Bytearray.Converts a BigInteger value to a byte array.

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.The value of the current BigInteger object converted to an array of bytes.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie bestimmte BigInteger Werte werden in Bytearrays dargestellt.The following example illustrates how some BigInteger values are represented in byte arrays.

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 zurückgegeben, die von dieser Methode werden in little-Endian-Reihenfolge angezeigt.The individual bytes in the array returned by this method appear in little-endian order. Die niederwertigen Bytes des Wertes vorausgehen, also die höherwertigen Bytes.That is, the lower-order bytes of the value precede the higher-order bytes. Das erste Byte des Arrays gibt die ersten acht Bits die BigInteger das zweite Byte-Wert gibt den nächsten acht Bits und So weiter.The first byte of the array reflects the first eight bits of the BigInteger value, the second byte reflects the next eight bits, and so on. Beispielsweise wird der Wert von 1024 oder 0 x 0400, wie das folgende Array von zwei Bytes gespeichert:For example, the value 1024, or 0x0400, is stored as the following array of two bytes:

ElementElement Byte-WertByte value
00 0x000x00
11 0x040x04

Negative Werte werden in das Array mit zwei der Ergänzung Ihrer Darstellung in die kompakteste Form möglichen geschrieben.Negative values are written to the array using two's complement representation in the most compact form possible. -1 wird beispielsweise als ein einzelnes Byte, dessen Wert, dargestellt 0xFF statt als ein Array mit mehreren Elementen, z. B. 0xFF, 0xFF oder 0xFF, 0xFF, 0xFF, 0xFF.For example, -1 is represented as a single byte whose value is 0xFF instead of as an array with multiple elements, such as 0xFF, 0xFF or 0xFF, 0xFF, 0xFF, 0xFF.

Da Darstellung immer Zweierkomplement interpretiert das höchstwertige Bit der das letzte Byte im Array (das Byte, ab Position Array.Length - 1) als Vorzeichenbit, gibt die Methode ein Bytearray mit der ein zusätzliches Element, dessen Wert 0 (null ist) zurück, mit denen auf unterscheiden Sie positive Werte, die andernfalls interpretiert werden konnte, als trügen ihre Anmelde-Bits festgelegt.Because two's complement representation always interprets the highest-order bit of the last byte in the array (the byte at position Array.Length- 1) as the sign bit, the method returns a byte array with an extra element whose value is zero to disambiguate positive values that could otherwise be interpreted as having their sign bits set. Z. B. den Wert 120 oder 0x78 wird als Single-Byte-Array dargestellt: 0x78.For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. Jedoch 128 oder 0x80, wird als ein 2-Byte-Array dargestellt: 0x80, 0x00.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

Sie können einen Roundtrip eine BigInteger Wert durch die Speicherung in ein Bytearray aus, und klicken Sie dann wiederherstellen mithilfe der BigInteger(Byte[]) Konstruktor.You can round-trip a BigInteger value by storing it to a byte array and then restoring it using the BigInteger(Byte[]) constructor.

Achtung

Wenn Ihr Code den Wert der einzelnen Bytes im Array ändert, von dieser Methode zurückgegeben wird, bevor sie den Wert wiederhergestellt wird, müssen Sie sicherstellen, dass nicht versehentlich das signierte Bit zu ändern.If your code modifies the value of individual bytes in the array returned by this method before it restores the value, you must make sure that you do not unintentionally change the sign bit. Werden z. B. wenn die Änderungen einen positiven Wert erhöhen, sodass der höchsten Priorität in das letzte Element des Bytearrays bit festgelegt ist, wird Sie einen neuen Byte hinzufügen können, deren Wert 0 (null) bis zum Ende des Arrays ist.For example, if your modifications increase a positive value so that the highest-order bit in the last element of the byte array becomes set, you can add a new byte whose value is zero to the end of the array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)

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

Byte[]

Gilt für: