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)

Liefert den Wert dieses BigInteger als Bytearray mit der kleinstmöglichen Anzahl von Bytes.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Wenn der Wert Null (0) ist, wird ein Array von einem Byte zurückgegeben, dessen Element 0x00 ist.If the value is zero, returns an array of one byte whose element is 0x00.

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, BigInteger wie einige Werte in Byte Arrays dargestellt werden.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, die von dieser Methode zurückgegeben werden, werden in Little-in-der-Reihenfolge angezeigtThe individual bytes in the array returned by this method appear in little-endian order. Das heißt, die nieder wertigen Bytes des Werts vor den Bytes höherer Reihenfolge.That is, the lower-order bytes of the value precede the higher-order bytes. Das erste Byte des Arrays reflektiert die ersten acht Bits des BigInteger Werts, das zweite Byte zeigt die nächsten acht Bits an usw.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 1024 oder 0x0400 als das folgende Array von zwei Bytes gespeichert:For example, the value 1024, or 0x0400, is stored as the following array of two bytes:

ElementElement BytewertByte value
00 0x000x00
11 0x040x04

Negative Werte werden in das Array geschrieben, wobei die zwei Komplement Darstellung in der möglichst kompakten Form verwendet wird.Negative values are written to the array using two's complement representation in the most compact form possible. Beispielsweise wird-1 als einzelnes Byte dargestellt, dessen Wert anstelle von 0xFF als Array mit mehreren Elementen ( 0xFFz 0xFF . b. oder 0xFF, 0xFF 0xFF,, 0xFF) ist.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 in der zwei Komplement-Darstellung immer das höchste Bit des letzten Bytes im Array (das Byte an der Position Array.Length - 1) als Signier Bit interpretiert wird, gibt die Methode ein Bytearray mit einem zusätzlichen Element zurück, dessen Wert 0 (null) ist. Geben Sie positive Werte eindeutig an, die andernfalls so interpretiert werden können, dass Sie Ihre Signier Bits festgelegt haben.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. Beispielsweise wird der Wert 120 oder 0x78 als Einzel Byte-Array dargestellt:. 0x78For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. 128, oder 0x80, wird jedoch als 2-Byte-Array dargestellt: 0x80, 0x00.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

Sie können einen Roundtrip für BigInteger einen Wert durchsetzen, indem Sie ihn in einem Bytearray speichern BigInteger(Byte[]) und dann mit dem-Konstruktor wiederherstellen.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 der Code den Wert einzelner Bytes in dem Array ändert, das von dieser Methode zurückgegeben wird, bevor der Wert wieder hergestellt wird, müssen Sie sicherstellen, dass das Signier Bit nicht versehentlich geändert wird.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. Wenn die Änderungen z. b. einen positiven Wert erhöhen, sodass das Bit mit der höchsten Ordnung im letzten Element des Byte Arrays festgelegt wird, können Sie ein neues Byte hinzufügen, dessen 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)

Liefert den Wert dieses BigInteger als Bytearray mit der kleinstmöglichen Anzahl von Bytes.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Wenn der Wert Null (0) ist, wird ein Array von einem Byte zurückgegeben, dessen Element 0x00 ist.If the value is zero, returns an array of one byte whose element is 0x00.

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 Boolean Boolean Boolean

true, um die Codierung ohne Vorzeichen zu verwenden, andernfalls false.true to use unsigned encoding; otherwise, false.

isBigEndian
Boolean Boolean Boolean Boolean

true, um die Bytes in einer Big-Endian-Bytereihenfolge zu schreiben, andernfalls false.true to write the bytes in a big-endian byte order; otherwise, false.

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.

Ausnahmen

Wenn isUnsigned true und Sign negativ ist.If isUnsigned is true and Sign is negative.

Hinweise

Der ganzzahlige Wert 33022 kann in vier unterschiedlichen Arrays exportiert werden:The integer value 33022 can be exported in four different arrays:

EigenschaftenProperties ErgebnisResult
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 }

Gilt für: