BigInteger.ToByteArray Méthode

Définition

Surcharges

ToByteArray()

Convertit une valeur BigInteger en tableau d'octets.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Retourne la valeur de ce BigInteger sous la forme d’un tableau d’octets en utilisant le plus petit nombre d’octets possible.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Si la valeur est égale à zéro, retourne un tableau d’un octet dont l’élément est 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToByteArray()

Convertit une valeur BigInteger en tableau d'octets.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()

Retours

Byte[]

Valeur de l'objet BigInteger actif convertie en tableau d'octets.The value of the current BigInteger object converted to an array of bytes.

Exemples

L’exemple suivant illustre la façon dont certaines valeurs de BigInteger sont représentées dans des tableaux d’octets.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

Remarques

Les octets individuels dans le tableau retourné par cette méthode s’affichent dans l’ordre de primauté des octets de poids faible.The individual bytes in the array returned by this method appear in little-endian order. Autrement dit, les octets de poids faible de la valeur précèdent les octets d’ordre supérieur.That is, the lower-order bytes of the value precede the higher-order bytes. Le premier octet du tableau reflète les huit premiers bits de la valeur BigInteger, le deuxième octet reflète les huit bits suivants, et ainsi de suite.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. Par exemple, la valeur 1024, ou 0x0400, est stockée en tant que tableau de deux octets suivant :For example, the value 1024, or 0x0400, is stored as the following array of two bytes:

ÉlémentElement Valeur d’octetByte value
00 0x000x00
11 0x040x04

Les valeurs négatives sont écrites dans le tableau à l’aide de la représentation de complément à deux dans le format le plus compact possible.Negative values are written to the array using two's complement representation in the most compact form possible. Par exemple,-1 est représenté sous la forme d’un octet unique dont la valeur est 0xFF plutôt que sous la forme d’un tableau avec plusieurs éléments, comme 0xFF, 0xFF ou 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.

Étant donné que la représentation du complément à deux interprète toujours le bit d’ordre le plus élevé du dernier octet du tableau (l’octet à la position Array.Length- 1) comme bit de signe, la méthode retourne un tableau d’octets avec un élément supplémentaire dont la valeur est égale à zéro pour lever l’ambiguïté des valeurs positives qui pourraient autrement être interprétées comme ayant leurs bits de signe définis.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. Par exemple, la valeur 120 ou 0x78 est représentée sous la forme d’un tableau codé sur un octet : 0x78.For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. Toutefois, 128, ou 0x80, est représenté sous la forme d’un tableau de deux octets : 0x80, 0x00.However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00.

Vous pouvez effectuer un aller-retour d’une valeur BigInteger en la stockant dans un tableau d’octets, puis en la restaurant à l’aide du constructeur BigInteger(Byte[]).You can round-trip a BigInteger value by storing it to a byte array and then restoring it using the BigInteger(Byte[]) constructor.

Attention

Si votre code modifie la valeur des octets individuels dans le tableau retourné par cette méthode avant de restaurer la valeur, vous devez vous assurer que vous ne modifiez pas involontairement le bit de signe.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. Par exemple, si vos modifications augmentent une valeur positive afin que le bit de poids le plus élevé dans le dernier élément du tableau d’octets devienne défini, vous pouvez ajouter un nouvel octet dont la valeur est égale à zéro à la fin du tableau.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)

Retourne la valeur de ce BigInteger sous la forme d’un tableau d’octets en utilisant le plus petit nombre d’octets possible.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Si la valeur est égale à zéro, retourne un tableau d’un octet dont l’élément est 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()

Paramètres

isUnsigned
Boolean

true pour utiliser l’encodage non signé ; sinon, false.true to use unsigned encoding; otherwise, false.

isBigEndian
Boolean

true pour écrire les octets dans un ordre d’octet de poids fort (big-endian) ; sinon, false.true to write the bytes in a big-endian byte order; otherwise, false.

Retours

Byte[]

Valeur de l'objet BigInteger actif convertie en tableau d'octets.The value of the current BigInteger object converted to an array of bytes.

Exceptions

Si isUnsigned est true et Sign est un nombre négatif.If isUnsigned is true and Sign is negative.

Remarques

La valeur entière 33022 peut être exportée dans quatre tableaux différents :The integer value 33022 can be exported in four different arrays:

PropriétésProperties RésultatResult
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 }

S’applique à