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

Definizione

Overload

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

Converte un valore BigInteger in una matrice di byte.Converts a BigInteger value to a byte array.

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

Restituisce il valore di BigInteger come matrice di byte usando il minor numero possibile di byte.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Se il valore è zero, restituisce una matrice di un byte il cui elemento è 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

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

Converte un valore BigInteger in una matrice di byte.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()

Restituisce

Byte[]

Valore dell'oggetto BigInteger corrente convertito in una matrice di byte.The value of the current BigInteger object converted to an array of bytes.

Esempi

Nell'esempio seguente viene illustrato il modo BigInteger in cui alcuni valori sono rappresentati in matrici di byte.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

Commenti

I singoli byte della matrice restituiti da questo metodo vengono visualizzati in ordine little-endian.The individual bytes in the array returned by this method appear in little-endian order. Ovvero i byte di ordine inferiore del valore precedono i byte di ordine superiore.That is, the lower-order bytes of the value precede the higher-order bytes. Il primo byte della matrice riflette i primi otto bit del BigInteger valore, il secondo byte riflette i successivi otto bit e così via.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. Ad esempio, il valore 1024, o 0x0400, viene archiviato come la seguente matrice di due byte:For example, the value 1024, or 0x0400, is stored as the following array of two bytes:

ElementoElement Valore byteByte value
00 0x000x00
11 0x040x04

I valori negativi vengono scritti nella matrice utilizzando la rappresentazione in complemento a due nella forma più compatta possibile.Negative values are written to the array using two's complement representation in the most compact form possible. Ad esempio,-1 è rappresentato come un singolo byte il cui valore 0xFF è anziché come matrice con più elementi, 0xFFad 0xFF esempio o 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.

Poiché la rappresentazione di complemento di due interpreta sempre il bit più alto dell'ultimo byte della matrice (il byte alla posizione Array.Length - 1) come bit del segno, il metodo restituisce una matrice di byte con un elemento aggiuntivo il cui valore è pari a zero Elimina l'ambiguità dei valori positivi che altrimenti potrebbero essere interpretati come aventi i bit di segno impostati.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. Ad esempio, il valore 120 o 0x78 è rappresentato come una matrice a byte singolo: 0x78.For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. Tuttavia, 128 o 0x80, è rappresentato come una matrice a due byte 0x00: 0x80.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

È possibile eseguire il round trip BigInteger di un valore archiviarlo in una matrice di byte e quindi ripristinarlo BigInteger(Byte[]) utilizzando il costruttore.You can round-trip a BigInteger value by storing it to a byte array and then restoring it using the BigInteger(Byte[]) constructor.

Attenzione

Se il codice modifica il valore dei singoli byte nella matrice restituita da questo metodo prima di ripristinare il valore, è necessario assicurarsi di non modificare involontariamente il bit di segno.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. Se, ad esempio, le modifiche aumentano un valore positivo in modo da impostare il bit di ordine più alto nell'ultimo elemento della matrice di byte, è possibile aggiungere un nuovo byte il cui valore è pari a zero alla fine della matrice.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)

Restituisce il valore di BigInteger come matrice di byte usando il minor numero possibile di byte.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Se il valore è zero, restituisce una matrice di un byte il cui elemento è 0x00.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()

Parametri

isUnsigned
Boolean Boolean Boolean Boolean

true per usare la codifica senza segno; in caso contrario, false.true to use unsigned encoding; otherwise, false.

isBigEndian
Boolean Boolean Boolean Boolean

true per scrivere i byte in un ordine di byte big endian; in caso contrario, false.true to write the bytes in a big-endian byte order; otherwise, false.

Restituisce

Byte[]

Valore dell'oggetto BigInteger corrente convertito in una matrice di byte.The value of the current BigInteger object converted to an array of bytes.

Eccezioni

Se isUnsigned è true e Sign è negativo.If isUnsigned is true and Sign is negative.

Commenti

Il valore 33022 Integer può essere esportato in quattro matrici diverse:The integer value 33022 can be exported in four different arrays:

ProprietàProperties RisultatoResult
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 }

Si applica a