BigInteger.ToByteArray Méthode

Définition

Surcharges

ToByteArray()

Convertit une valeur BigInteger en tableau d'octets.

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. Si la valeur est égale à zéro, retourne un tableau d’un octet dont l’élément est 0x00.

ToByteArray()

Convertit une valeur BigInteger en tableau d'octets.

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.

Exemples

L’exemple suivant montre comment certaines BigInteger valeurs sont représentées dans des tableaux d’octets.

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. Autrement dit, les octets de poids faible de la valeur précèdent les octets d’ordre supérieur. Le premier octet du tableau reflète les huit premiers bits de la BigInteger valeur, le deuxième octet reflète les huit bits suivants, et ainsi de suite. Par exemple, la valeur 1024, ou 0x0400, est stockée en tant que tableau de deux octets suivant :

Élément Valeur d'octet
0 0x00
1 0x04

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. 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, tels que 0xFF , 0xFF ou 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 dans le tableau (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. Par exemple, la valeur 120 ou 0x78 est représentée comme un tableau codé sur un octet : 0x78 . Toutefois, 128, ou 0x80 , est représenté sous la forme d’un tableau de deux octets : 0x80 , 0x00 .

Vous pouvez effectuer un aller-retour d’une BigInteger valeur en la stockant dans un tableau d’octets, puis en la restaurant à l’aide du BigInteger(Byte[]) constructeur.

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

S’applique à

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. Si la valeur est égale à zéro, retourne un tableau d’un octet dont l’élément est 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.

isBigEndian
Boolean

true pour écrire les octets dans un ordre d’octet de poids fort (big-endian) ; sinon, false.

Retours

Byte[]

Valeur de l'objet BigInteger actif convertie en tableau d'octets.

Exceptions

Si isUnsigned est true et Sign est un nombre négatif.

Remarques

La valeur entière 33022 peut être exportée dans quatre tableaux différents :

Propriétés Résultats
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 à