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

Definición

Sobrecargas

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

Convierte un valor BigInteger en una matriz de bytes.Converts a BigInteger value to a byte array.

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

Devuelve el valor de este objeto BigInteger como una matriz de bytes usando el menor número de bytes posible.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Si el valor es cero, devuelve una matriz de un byte cuyo elemento es 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

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

Convierte un valor BigInteger en una 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()

Devoluciones

Byte[]

Valor del objeto BigInteger actual convertido en una matriz de bytes.The value of the current BigInteger object converted to an array of bytes.

Ejemplos

En el ejemplo siguiente se muestra cómo BigInteger se representan algunos valores en las matrices 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

Comentarios

Los bytes individuales de la matriz devueltos por este método aparecen en orden Little-Endian.The individual bytes in the array returned by this method appear in little-endian order. Es decir, los bytes de orden inferior del valor preceden a los bytes de orden superior.That is, the lower-order bytes of the value precede the higher-order bytes. El primer byte de la matriz refleja los primeros ocho bits del BigInteger valor, el segundo byte refleja los siguientes ocho bits, etc.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 ejemplo, el valor 1024 o 0x0400 se almacena como la siguiente matriz de dos 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

Los valores negativos se escriben en la matriz utilizando la representación del complemento de dos en la forma más compacta posible.Negative values are written to the array using two's complement representation in the most compact form possible. Por ejemplo,-1 se representa como un byte único cuyo valor es 0xFF en lugar de una matriz con varios elementos, 0xFFcomo, 0xFF 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.

Dado que la representación del complemento de dos siempre interpreta el bit de orden superior del último byte de la matriz (el byte en Array.Lengthla posición - 1) como el bit de signo, el método devuelve una matriz de bytes con un elemento adicional cuyo valor es cero para Elimine la ambigüedad de los valores positivos que de otro modo podrían interpretarse como si se hubieran establecido sus bits de signo.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 ejemplo, el valor 120 o 0x78 se representa como una matriz de un solo byte 0x78:.For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. Sin embargo, 128, 0x80o, se representa como una matriz de dos bytes 0x00: 0x80,.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

Puede realizar una operación de ida BigInteger y vuelta de un valor almacenándolo en una matriz de bytes y, a BigInteger(Byte[]) continuación, restaurarlo mediante el constructor.You can round-trip a BigInteger value by storing it to a byte array and then restoring it using the BigInteger(Byte[]) constructor.

Precaución

Si el código modifica el valor de los bytes individuales de la matriz devuelta por este método antes de restaurar el valor, debe asegurarse de que no cambia accidentalmente el bit de signo.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 ejemplo, si las modificaciones aumentan un valor positivo para que se establezca el bit de orden superior del último elemento de la matriz de bytes, puede Agregar un nuevo byte cuyo valor sea cero al final de la 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)

Devuelve el valor de este objeto BigInteger como una matriz de bytes usando el menor número de bytes posible.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Si el valor es cero, devuelve una matriz de un byte cuyo elemento es 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 la codificación sin signo; de lo contrario, false.true to use unsigned encoding; otherwise, false.

isBigEndian
Boolean Boolean Boolean Boolean

true para escribir los bytes en un orden de bytes big endian; de lo contrario, false.true to write the bytes in a big-endian byte order; otherwise, false.

Devoluciones

Byte[]

Valor del objeto BigInteger actual convertido en una matriz de bytes.The value of the current BigInteger object converted to an array of bytes.

Excepciones

Si isUnsigned es true y Sign es negativo.If isUnsigned is true and Sign is negative.

Comentarios

El valor 33022 entero se puede exportar en cuatro matrices diferentes:The integer value 33022 can be exported in four different arrays:

PropiedadesProperties 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 }

Se aplica a