BigInteger.ToByteArray Méthode

Définition

Espace de noms:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

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()

Source:

BigInteger.cs

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 illustre la façon dont 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

open System
open System.Numerics

let numbers =
    [| BigInteger.MinusOne
       BigInteger.One
       BigInteger.Zero
       120
       128
       255
       1024
       Int64.MinValue
       Int64.MaxValue
       BigInteger.Parse("90123123981293054321") |]

for number in numbers do
    let bytes = number.ToByteArray()
    printf $"""{number} ({number.ToString("X" + (bytes.Length * 2).ToString())}) -> """
    printf $"{bytes.Length} bytes: "

    for byteValue in bytes do
        printf $"{byteValue:X2} "

    printfn ""

// 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 du tableau retournés par cette méthode s’affichent dans un ordre peu endien. Autrement dit, les octets d’ordre inférieur 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 sous la forme du tableau suivant de deux octets :

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

Les valeurs négatives sont écrites dans le tableau à l’aide de la représentation du complément de deux dans la forme la plus compacte possible. Par exemple, -1 est représenté sous la forme d’un seul octet dont la valeur est au lieu d’un 0xFF tableau avec plusieurs éléments, tels que 0xFF, 0xFF ou 0xFF, 0xFF, 0xFF0xFF.

Étant donné que la représentation complémentaire de deux interprète toujours le bit d’ordre le plus élevé du dernier octet du tableau (l’octet à la position Array.Length- 1) comme le bit de signe, la méthode retourne un tableau d’octets avec un élément supplémentaire dont la valeur est 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 sous la forme d’un tableau d’un octet : 0x78. Toutefois, 128, ou 0x80, est représenté sous la forme d’un tableau de deux octets : 0x80, 0x00.

Vous pouvez aller-retour 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 d’octets individuels dans le tableau retourné par cette méthode avant qu’elle ne restaure 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 de sorte que le bit d’ordre le plus élevé du dernier élément du tableau d’octets soit défini, vous pouvez ajouter un nouvel octet dont la valeur est égale à zéro à la fin du tableau.

ToByteArray(Boolean, Boolean)

Source:

BigInteger.cs

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

OverflowException

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

Remarques

La valeur 33022 entière 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 }