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

Definição

Sobrecargas

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

Converte um valor de BigInteger em uma matriz de bytes.Converts a BigInteger value to a byte array.

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

Retorna o valor deste BigInteger como uma matriz de bytes usando o menor número possível de bytes.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Se o valor é zero, retorna uma matriz de um byte cujo elemento é 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

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

Converte um valor de BigInteger em uma matriz de bytes.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()

Retornos

Byte[]

O valor do objeto BigInteger atual convertido em uma matriz de bytes.The value of the current BigInteger object converted to an array of bytes.

Exemplos

O exemplo a seguir ilustra como BigInteger alguns valores são representados em matrizes de bytes.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

Comentários

Os bytes individuais na matriz retornados por esse método aparecem na ordem little-endian.The individual bytes in the array returned by this method appear in little-endian order. Ou seja, os bytes de ordem inferior do valor precedem os bytes de ordem superior.That is, the lower-order bytes of the value precede the higher-order bytes. O primeiro byte da matriz reflete os oito primeiros bits do BigInteger valor, o segundo byte reflete os próximos oito bits e assim por diante.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. Por exemplo, o valor 1024, ou 0x0400, é armazenado como a seguinte matriz de dois bytes:For example, the value 1024, or 0x0400, is stored as the following array of two bytes:

ElementoElement Valor de byteByte value
00 0x000x00
11 0x040x04

Valores negativos são gravados na matriz usando a representação complementar de duas no formato mais compacto possível.Negative values are written to the array using two's complement representation in the most compact form possible. Por exemplo,-1 é representado como um único byte cujo valor é 0xFF em vez de uma matriz com vários elementos, 0xFFcomo 0xFF, 0xFF ou 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.

Como a representação complementar de duas é sempre interpreta o bit de ordem mais alta do último byte na matriz (o byte na posição Array.Length - 1) como o bit de sinal, o método retorna uma matriz de bytes com um elemento extra cujo valor é zero para desambiguar valores positivos que poderiam, de outra forma, ser interpretados como tendo seus bits de sinal definidos.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. Por exemplo, o valor 120 ou 0x78 é representado como uma matriz de byte único: 0x78.For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. No entanto, 128 0x80, ou, é representado como uma matriz de dois 0x80bytes 0x00:,.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

Você pode fazer ida e volta BigInteger de um valor armazenando-o em uma matriz de bytes e, BigInteger(Byte[]) em seguida, restaurando-o usando o construtor.You can round-trip a BigInteger value by storing it to a byte array and then restoring it using the BigInteger(Byte[]) constructor.

Cuidado

Se o seu código modificar o valor de bytes individuais na matriz retornada por esse método antes de restaurar o valor, você deverá certificar-se de que você não altere involuntariamente o bit de sinal.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. Por exemplo, se suas modificações aumentarem um valor positivo para que o bit de ordem mais alta no último elemento da matriz de bytes se torne definido, você poderá adicionar um novo byte cujo valor seja zero ao final da matriz.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)

Retorna o valor deste BigInteger como uma matriz de bytes usando o menor número possível de bytes.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Se o valor é zero, retorna uma matriz de um byte cujo 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()

Parâmetros

isUnsigned
Boolean Boolean Boolean Boolean

true para usar a codificação sem sinal; caso contrário, false.true to use unsigned encoding; otherwise, false.

isBigEndian
Boolean Boolean Boolean Boolean

true para gravar os bytes em uma ordem de byte big endian; caso contrário, false.true to write the bytes in a big-endian byte order; otherwise, false.

Retornos

Byte[]

O valor do objeto BigInteger atual convertido em uma matriz de bytes.The value of the current BigInteger object converted to an array of bytes.

Exceções

Se isUnsigned é true, e Sign é negativo.If isUnsigned is true and Sign is negative.

Comentários

O valor 33022 inteiro pode ser exportado em quatro matrizes diferentes:The integer value 33022 can be exported in four different arrays:

PropriedadesProperties ResultadoResult
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 }

Aplica-se a