BigInteger Structure

Définition

Représente un entier signé arbitrairement grand.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable
type BigInteger = struct
    interface IFormattable
    interface ISpanFormattable
[<System.Serializable>]
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable
Héritage
BigInteger
Attributs
Implémente

Remarques

Le type est un type immuable qui représente un entier arbitrairement volumineux dont la BigInteger valeur en théorie n’a aucune limite supérieure ou inférieure. Les membres du BigInteger type sont étroitement parallèles à ceux d’autres types intégral (le Byte, Int16, Int32Int64, SByte, UInt16, , , et UInt32UInt64 les types). Ce type diffère des autres types intégraux du .NET Framework, qui ont une plage indiquée par leurs propriétés et MaxValue leurs MinValue propriétés.

Notes

Étant donné que le BigInteger type est immuable (voir Mutability et la structure BigInteger) et parce qu’il n’a pas de limites supérieures ou inférieures, une OutOfMemoryException opération peut être levée pour toute opération qui provoque une BigInteger croissance trop grande.

Instanciation d’un objet BigInteger

Vous pouvez instancier un BigInteger objet de plusieurs façons :

  • Vous pouvez utiliser le new mot clé et fournir une valeur intégrale ou à virgule flottante comme paramètre au BigInteger constructeur. (Les valeurs à virgule flottante sont tronquées avant qu’elles ne soient affectées au BigInteger.) L’exemple suivant montre comment utiliser le new mot clé pour instancier des BigInteger valeurs.

    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952
    
    Dim bigIntFromDouble As New BigInteger(179032.6541)
    Console.WriteLine(bigIntFromDouble)
    Dim bigIntFromInt64 As New BigInteger(934157136952)
    Console.WriteLine(bigIntFromInt64)
    ' The example displays the following output:
    '   179032
    '   934157136952
    
  • Vous pouvez déclarer une BigInteger variable et l’affecter comme vous le feriez pour n’importe quel type numérique, tant que cette valeur est un type intégral. L’exemple suivant utilise l’affectation pour créer une BigInteger valeur à partir d’un Int64.

    long longValue = 6315489358112;
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • Vous pouvez affecter une valeur décimale ou à virgule flottante à un BigInteger objet si vous castez la valeur ou convertissez-la en premier. L’exemple suivant caste explicitement (en C#) ou convertit (en Visual Basic) a Double et une Decimal valeur en un BigInteger.

    BigInteger assignedFromDouble = (BigInteger) 179032.6541;
    Console.WriteLine(assignedFromDouble);
    BigInteger assignedFromDecimal = (BigInteger) 64312.65m;
    Console.WriteLine(assignedFromDecimal);
    // The example displays the following output:
    //   179032
    //   64312
    
    Dim assignedFromDouble As BigInteger = CType(179032.6541, BigInteger)
    Console.WriteLine(assignedFromDouble)   
    Dim assignedFromDecimal As BigInteger = CType(64312.65d, BigInteger)      
    Console.WriteLine(assignedFromDecimal)
    ' The example displays the following output:
    '   179032
    '   64312
    

Ces méthodes vous permettent d’instancier un BigInteger objet dont la valeur se trouve dans la plage d’un des types numériques existants uniquement. Vous pouvez instancier un BigInteger objet dont la valeur peut dépasser la plage des types numériques existants de l’une des trois manières suivantes :

  • Vous pouvez utiliser le new mot clé et fournir un tableau d’octets de n’importe quelle taille au BigInteger.BigInteger constructeur. Exemple :

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • Vous pouvez appeler les Parse méthodes ou TryParse les méthodes pour convertir la représentation sous forme de chaîne d’un nombre en un BigInteger. Exemple :

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • Vous pouvez appeler une static méthode (Shareddans Visual Basic) BigInteger qui effectue une opération sur une expression numérique et retourne un résultat calculéBigInteger. L’exemple suivant effectue cette opération en cubing UInt64.MaxValue et en affectant le résultat à un BigInteger.

    BigInteger number = BigInteger.Pow(UInt64.MaxValue, 3);
    Console.WriteLine(number);
    // The example displays the following output:
    //    6277101735386680762814942322444851025767571854389858533375
    
    Dim number As BigInteger = BigInteger.Pow(UInt64.MaxValue, 3)
    Console.WriteLine(number)
    ' The example displays the following output:
      ' 6277101735386680762814942322444851025767571854389858533375
    

La valeur non initialisée d’un BigInteger est Zero.

Exécution d’opérations sur les valeurs BigInteger

Vous pouvez utiliser une BigInteger instance comme vous l’utiliseriez n’importe quel autre type intégral. BigInteger surcharge les opérateurs numériques standard pour vous permettre d’effectuer des opérations mathématiques de base telles que l’addition, la soustraction, la division, la multiplication, la soustraction, la négation et la négation nonaire. Vous pouvez également utiliser les opérateurs numériques standard pour comparer deux BigInteger valeurs entre elles. Comme les autres types intégral, BigInteger prend également en charge les opérateurs bitwise And, Or, XOr, left shift et right shift. Pour les langages qui ne prennent pas en charge les opérateurs personnalisés, la BigInteger structure fournit également des méthodes équivalentes pour effectuer des opérations mathématiques. Ceux-ci incluent Add, NegateDivideMultiplySubtractet plusieurs autres.

De nombreux membres de la BigInteger structure correspondent directement aux membres des autres types intégral. En outre, BigInteger ajoute des membres tels que les éléments suivants :

  • Sign, qui retourne une valeur qui indique le signe d’une BigInteger valeur.

  • Abs, qui retourne la valeur absolue d’une BigInteger valeur.

  • DivRem, qui retourne à la fois le quotient et le reste d’une opération de division.

  • GreatestCommonDivisor, qui retourne le plus grand diviseur commun de deux BigInteger valeurs.

Un grand nombre de ces membres supplémentaires correspondent aux membres de la Math classe, ce qui fournit la fonctionnalité permettant d’utiliser les types numériques primitifs.

Mutabilité et structure BigInteger

L’exemple suivant instancie un BigInteger objet, puis incrémente sa valeur par un.

BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);
Dim number As BigInteger = BigInteger.Multiply(Int64.MaxValue, 3)
number += 1
Console.WriteLine(number)

Bien que cet exemple semble modifier la valeur de l’objet existant, ce n’est pas le cas. BigInteger les objets sont immuables, ce qui signifie qu’en interne, le common language runtime crée réellement un objet BigInteger et lui affecte une valeur supérieure à sa valeur précédente. Ce nouvel objet est ensuite retourné à l’appelant.

Notes

Les autres types numériques dans .NET sont également immuables. Toutefois, étant donné que le BigInteger type n’a pas de limites supérieures ou inférieures, ses valeurs peuvent croître extrêmement volumineuses et avoir un impact mesurable sur les performances.

Bien que ce processus soit transparent pour l’appelant, il entraîne une pénalité de performances. Dans certains cas, surtout lorsque des opérations répétées sont effectuées dans une boucle sur des valeurs très volumineuses BigInteger , cette pénalité de performances peut être significative. Par exemple, dans l’exemple suivant, une opération est effectuée de manière répétitive jusqu’à un million de fois, et une BigInteger valeur est incrémentée par une fois que l’opération réussit.

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   number++;
}
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   number += 1
Next

Dans ce cas, vous pouvez améliorer les performances en effectuant toutes les affectations intermédiaires à une Int32 variable. La valeur finale de la variable peut ensuite être affectée à l’objet BigInteger lorsque la boucle s’arrête. L'exemple suivant illustre cette situation.

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
int actualRepetitions = 0;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   actualRepetitions++;
}
number += actualRepetitions;
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
Dim actualRepetitions As Integer = 0
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   actualRepetitions += 1
Next
number += actualRepetitions

Utilisation de tableaux d’octets et de chaînes hexadécimales

Si vous convertissez BigInteger des valeurs en tableaux d’octets ou si vous convertissez des tableaux d’octets en BigInteger valeurs, vous devez prendre en compte l’ordre des octets. La BigInteger structure attend que les octets individuels d’un tableau d’octets apparaissent dans un ordre peu endian (autrement dit, les octets de l’ordre inférieur de la valeur précèdent les octets de l’ordre supérieur). Vous pouvez aller-retour sur une BigInteger valeur en appelant la ToByteArray méthode, puis en passant le tableau d’octets résultant au BigInteger(Byte[]) constructeur, comme l’illustre l’exemple suivant.

BigInteger number = BigInteger.Pow(Int64.MaxValue, 2);
Console.WriteLine(number);

// Write the BigInteger value to a byte array.
byte[] bytes = number.ToByteArray();

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0:X2} ", byteValue);
Console.WriteLine();

// Restore the BigInteger value from a Byte array.
BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine(newNumber);
// The example displays the following output:
//    8.5070591730234615847396907784E+37
//    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
//
//    8.5070591730234615847396907784E+37
Dim number As BigInteger = BigInteger.Pow(Int64.MaxValue, 2)     
Console.WriteLine(number)

' Write the BigInteger value to a byte array.
Dim bytes() As Byte = number.ToByteArray()

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0:X2} ", byteValue)
Next   
Console.WriteLine()

' Restore the BigInteger value from a Byte array.
Dim newNumber As BigInteger = New BigInteger(bytes)
Console.WriteLine(newNumber)               
' The example displays the following output:
'    8.5070591730234615847396907784E+37
'    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
'    
'    8.5070591730234615847396907784E+37

Pour instancier une BigInteger valeur à partir d’un tableau d’octets qui représente une valeur d’un autre type intégral, vous pouvez transmettre la valeur intégrale à la BitConverter.GetBytes méthode, puis transmettre le tableau d’octets résultant au BigInteger(Byte[]) constructeur. L’exemple suivant instancie une BigInteger valeur à partir d’un tableau d’octets qui représente une Int16 valeur.

short originalValue = 30000;
Console.WriteLine(originalValue);

// Convert the Int16 value to a byte array.
byte[] bytes = BitConverter.GetBytes(originalValue);

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0} ", byteValue.ToString("X2"));
Console.WriteLine();

// Pass byte array to the BigInteger constructor.
BigInteger number = new BigInteger(bytes);
Console.WriteLine(number);
// The example displays the following output:
//       30000
//       0x30 0x75
//       30000
Dim originalValue As Short = 30000
Console.WriteLine(originalValue)

' Convert the Int16 value to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalValue)

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0} ", byteValue.ToString("X2"))
Next    
Console.WriteLine() 

' Pass byte array to the BigInteger constructor.
Dim number As BigInteger = New BigInteger(bytes)
Console.WriteLine(number)
' The example displays the following output:
'       30000
'       0x30 0x75
'       30000

La BigInteger structure suppose que les valeurs négatives sont stockées à l’aide de la représentation complémentaire de deux. Étant donné que la BigInteger structure représente une valeur numérique sans longueur fixe, le BigInteger(Byte[]) constructeur interprète toujours le bit le plus significatif du dernier octet du tableau comme un bit de signe. Pour empêcher le BigInteger(Byte[]) constructeur de confondre la représentation complète des deux d’une valeur négative avec la représentation de signe et de magnitude d’une valeur positive, valeurs positives dans lesquelles le bit le plus significatif du dernier octet du tableau d’octets serait généralement défini doit inclure un octet supplémentaire dont la valeur est 0. Par exemple, 0xC0 0xBD 0xF0 0xFF est la représentation hexadécimale peu endienne de -1 000 000 ou 4 293 967 296. Étant donné que le bit le plus significatif du dernier octet de ce tableau est activé, la valeur du tableau d’octets est interprétée par le BigInteger(Byte[]) constructeur comme -1 000 000. Pour instancier une BigInteger valeur positive, un tableau d’octets dont les éléments sont 0xC0 0xBD 0xF0 0xFF 0x00 doivent être transmis au constructeur. L'exemple suivant illustre ce comportement.

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

byte[] negativeBytes = BitConverter.GetBytes(negativeNumber);
BigInteger negativeBigInt = new BigInteger(negativeBytes);
Console.WriteLine(negativeBigInt.ToString("N0"));

byte[] tempPosBytes = BitConverter.GetBytes(positiveNumber);
byte[] positiveBytes = new byte[tempPosBytes.Length + 1];
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length);
BigInteger positiveBigInt = new BigInteger(positiveBytes);
Console.WriteLine(positiveBigInt.ToString("N0"));
// The example displays the following output:
//    -1,000,000
//    4,293,967,296
Dim negativeNumber As Integer = -1000000
Dim positiveNumber As UInteger = 4293967296

Dim negativeBytes() As Byte = BitConverter.GetBytes(negativeNumber) 
Dim negativeBigInt As New BigInteger(negativeBytes)
Console.WriteLine(negativeBigInt.ToString("N0"))

Dim tempPosBytes() As Byte = BitConverter.GetBytes(positiveNumber)
Dim positiveBytes(tempposBytes.Length) As Byte
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length)
Dim positiveBigInt As New BigInteger(positiveBytes)
Console.WriteLine(positiveBigInt.ToString("N0")) 
' The example displays the following output:
'    -1,000,000
'    4,293,967,296

Les tableaux d’octets créés par la ToByteArray méthode à partir de valeurs positives incluent cet octet de valeur zéro supplémentaire. Par conséquent, la BigInteger structure peut effectuer des allers-retours en les affectant, puis en les rétablissant à partir de tableaux d’octets, comme l’illustre l’exemple suivant.

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"));
byte[] bytes = positiveValue.ToByteArray();

foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue = new BigInteger(bytes);
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"));

Console.WriteLine();

Console.WriteLine("Negative value: " + negativeValue.ToString("N0"));
bytes = negativeValue.ToByteArray();
foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue = new BigInteger(bytes);
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"));
// The example displays the following output:
//       Positive value: 15,777,216
//       C0 BD F0 00
//       Restored positive value: 15,777,216
//
//       Negative value: -1,000,000
//       C0 BD F0
//       Restored negative value: -1,000,000
Dim positiveValue As BigInteger = 15777216
Dim negativeValue As BigInteger = -1000000

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"))
Dim bytes() As Byte = positiveValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
positiveValue = New BigInteger(bytes)
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"))

Console.WriteLine()
   
Console.WriteLIne("Negative value: " + negativeValue.ToString("N0"))
bytes = negativeValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
negativeValue = New BigInteger(bytes)
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"))
' The example displays the following output:
'       Positive value: 15,777,216
'       C0 BD F0 00
'       Restored positive value: 15,777,216
'       
'       Negative value: -1,000,000
'       C0 BD F0
'       Restored negative value: -1,000,000

Toutefois, vous devrez peut-être ajouter cet octet de valeur zéro supplémentaire aux tableaux d’octets créés dynamiquement par le développeur ou retournés par des méthodes qui convertissent des entiers non signés en tableaux d’octets (tels que BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)et BitConverter.GetBytes(UInt64)).

Lors de l’analyse d’une chaîne hexadécimale, les BigInteger.Parse(String, NumberStyles) méthodes supposent BigInteger.Parse(String, NumberStyles, IFormatProvider) que si le bit le plus significatif du premier octet de la chaîne est défini, ou si le premier chiffre hexadécimal de la chaîne représente les quatre bits inférieurs d’une valeur d’octet, la valeur est représentée à l’aide de la représentation complémentaire de deux. Par exemple, « FF01 » et « F01 » représentent la valeur décimale -255. Pour différencier les valeurs positives des valeurs négatives, les valeurs positives doivent inclure un zéro de début. Les surcharges pertinentes de la ToString méthode, lorsqu’elles sont passées à la chaîne de format « X », ajoutez un zéro de début à la chaîne hexadécimale retournée pour les valeurs positives. Cela permet d’aller-retour BigInteger sur les valeurs à l’aide des méthodes et Parse des ToString méthodes, comme l’illustre l’exemple suivant.

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

string negativeHex = negativeNumber.ToString("X");
string positiveHex = positiveNumber.ToString("X");

BigInteger negativeNumber2, positiveNumber2;
negativeNumber2 = BigInteger.Parse(negativeHex,
                                   NumberStyles.HexNumber);
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber);

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   negativeNumber, negativeHex, negativeNumber2);
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   positiveNumber, positiveHex, positiveNumber2);
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.
Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

Dim negativeHex As String = negativeNumber.ToString("X")
Dim positiveHex As string = positiveNumber.ToString("X")

Dim negativeNumber2, positiveNumber2 As BigInteger 
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber)
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber)

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2)                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2)                                         
' The example displays the following output:
'       Converted -1,000,000 to F0BDC0 back to -1,000,000.
'       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.

Toutefois, les chaînes hexadécimales créées en appelant les ToString méthodes des autres types intégral ou les surcharges de la ToString méthode qui incluent un toBase paramètre n’indiquent pas le signe de la valeur ou du type de données source à partir duquel la chaîne hexadécimale a été dérivée. L’instanciation réussie d’une BigInteger valeur à partir d’une telle chaîne nécessite une logique supplémentaire. L’exemple suivant fournit une implémentation possible.

using System;
using System.Globalization;
using System.Numerics;

public struct HexValue
{
   public int Sign;
   public string Value;
}

public class Example
{
   public static void Main()
   {
      uint positiveNumber = 4039543321;
      int negativeNumber = -255423975;

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);

      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);

      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;

      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        positiveNumber, hexValue1.Value, positiveBigInt);

      hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        negativeNumber, hexValue2.Value, negativeBigInt);
   }
}
// The example displays the following output:
//       Converted 4039543321 to F0C68A19 and back to 4039543321.
//       Converted -255423975 to f0c68a19 and back to -255423975.
Imports System.Globalization
Imports System.Numerics

Public Structure HexValue
   Public Sign As Integer
   Public Value As String
End Structure
   
Module Example
   Public Sub Main()
      Dim positiveNumber As UInteger = 4039543321
      Dim negativeNumber As Integer = -255423975

      ' Convert the numbers to hex strings.
      Dim hexValue1, hexValue2 As HexValue
      hexValue1.Value = positiveNumber.ToString("X")
      hexValue1.Sign = Math.Sign(positiveNumber)
      
      hexValue2.Value = Convert.ToString(negativeNumber, 16)
      hexValue2.Sign = Math.Sign(negativeNumber)
      
      ' Round-trip the hexadecimal values to BigInteger values.
      Dim hexString As String
      Dim positiveBigInt, negativeBigInt As BigInteger
      
      hexString = CStr(IIf(hexValue1.Sign = 1, "0", "")) + hexValue1.Value
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt)

      hexString = CStr(IIf(hexValue2.Sign = 1, "0", "")) + hexValue2.Value
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt)

   End Sub
End Module
' The example displays the following output:
'       Converted 4039543321 to F0C68A19 and back to 4039543321.
'       Converted -255423975 to f0c68a19 and back to -255423975.

Constructeurs

BigInteger(Byte[])

Initialise une nouvelle instance de la structure BigInteger à l'aide des valeurs d'un tableau d'octets.

BigInteger(Decimal)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur Decimal.

BigInteger(Double)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante double précision.

BigInteger(Int32)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur d'entier 32 bits signé.

BigInteger(Int64)

Initialise une nouvelle instance de la structure BigInteger à l’aide d’une valeur d’entier 64 bits signé.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Initialise une nouvelle instance de la structure BigInteger à l’aide des valeurs d’une étendue en lecture seule d’octets et indique éventuellement l’encodage de signature et l’ordre d’octet en mode Endian.

BigInteger(Single)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante simple précision.

BigInteger(UInt32)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière 32 bits non signée.

BigInteger(UInt64)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière 64 bits non signée.

Propriétés

IsEven

Indique si la valeur de l'objet BigInteger actif est un nombre pair.

IsOne

Indique si la valeur de l'objet BigInteger actif est One.

IsPowerOfTwo

Indique si la valeur de l'objet BigInteger actif est une puissance de deux.

IsZero

Indique si la valeur de l'objet BigInteger actif est Zero.

MinusOne

Obtient une valeur qui représente le nombre moins un (-1).

One

Obtient une valeur qui représente le nombre un (1).

Sign

Obtient un nombre qui indique le signe (négatif, positif ou zéro) de l'objet BigInteger actif.

Zero

Obtient une valeur qui représente le nombre 0 (zéro).

Méthodes

Abs(BigInteger)

Obtient la valeur absolue d'un objet BigInteger.

Add(BigInteger, BigInteger)

Ajoute deux valeurs BigInteger et retourne le résultat.

Compare(BigInteger, BigInteger)

Compare deux valeurs BigInteger et retourne un entier qui indique si la première valeur est inférieure, égale ou supérieure à la seconde valeur.

CompareTo(BigInteger)

Compare cette instance à un second BigInteger et retourne un entier qui indique si la valeur de l'instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.

CompareTo(Int64)

Compare cette instance à un entier 64 bits signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits signé.

CompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.

CompareTo(UInt64)

Compare cette instance à un entier 64 bits non signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits non signé.

Divide(BigInteger, BigInteger)

Divise une valeur BigInteger par une autre et retourne le résultat.

DivRem(BigInteger, BigInteger, BigInteger)

Divise une valeur BigInteger par une autre, retourne le résultat, puis retourne le modulo dans un paramètre de sortie.

Equals(BigInteger)

Retourne une valeur qui indique si l'instance actuelle et un objet BigInteger spécifié ont la même valeur.

Equals(Int64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits signé ont la même valeur.

Equals(Object)

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.

Equals(UInt64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits non signé ont la même valeur.

GetBitLength()

Obtient le nombre de bits requis pour la représentation du complément le plus court des deux de l’instance actuelle sans le bit de signe.

GetByteCount(Boolean)

Obtient le nombre d’octets qui seront générés par ToByteArray(Boolean, Boolean) et TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).

GetHashCode()

Retourne le code de hachage pour l'objet BigInteger actuel.

GreatestCommonDivisor(BigInteger, BigInteger)

Recherche le plus grand commun diviseur de deux valeurs BigInteger.

Log(BigInteger)

Retourne le logarithme naturel (base e) d'un nombre spécifié.

Log(BigInteger, Double)

Retourne le logarithme d'un nombre spécifié dans une base spécifiée.

Log10(BigInteger)

Retourne le logarithme de base 10 d'un nombre spécifié.

Max(BigInteger, BigInteger)

Retourne la plus grande des deux valeurs BigInteger.

Min(BigInteger, BigInteger)

Retourne la plus petite des deux valeurs BigInteger.

ModPow(BigInteger, BigInteger, BigInteger)

Effectue une division avec coefficient sur un nombre élevé à la puissance d'un autre nombre.

Multiply(BigInteger, BigInteger)

Retourne le produit de deux valeurs BigInteger.

Negate(BigInteger)

Rend négative la valeur BigInteger spécifiée.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation d’un nombre, contenue dans l’étendue en lecture seule de caractères indiquée, dans un style spécifié en son équivalent BigInteger.

Parse(String)

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.

Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation BigInteger équivalente.

Parse(String, NumberStyles)

Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent BigInteger.

Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation BigInteger équivalente.

Pow(BigInteger, Int32)

Élève une valeur BigInteger à la puissance de la valeur spécifiée.

Remainder(BigInteger, BigInteger)

Effectue une division entière sur deux valeurs BigInteger et retourne le modulo.

Subtract(BigInteger, BigInteger)

Soustrait une valeur BigInteger d'une autre valeur et retourne le résultat.

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.

ToString()

Convertit la valeur numérique de l'objet BigInteger actuel dans sa représentation sous forme chaîne équivalente.

ToString(IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide des informations spécifiées de mise en forme spécifiques à la culture.

ToString(String)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

ToString(String, IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide du format spécifié et des informations de mise en forme spécifiques à la culture.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Met en forme cette instance d’entier très grand dans une étendue de caractères.

TryParse(ReadOnlySpan<Char>, BigInteger)

Tente de convertir la représentation d’un nombre contenu dans l’étendue en lecture seule de caractères spécifiée en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

TryParse(String, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

Copie la valeur de ce BigInteger en tant qu’octets de complément à deux de poids faible (little-endian), en utilisant le plus petit nombre d’octets possible. Si la valeur est égale à zéro, génère un octet dont l’élément est 0x00.

Opérateurs

Addition(BigInteger, BigInteger)

Ajoute les valeurs des deux objets BigInteger spécifiés.

BitwiseAnd(BigInteger, BigInteger)

Effectue une opération de bits And sur deux valeurs BigInteger.

BitwiseOr(BigInteger, BigInteger)

Effectue une opération de bits Or sur deux valeurs BigInteger.

Decrement(BigInteger)

Décrémente une valeur BigInteger de 1.

Division(BigInteger, BigInteger)

Divise une valeur BigInteger spécifique par une autre valeur BigInteger spécifique à l'aide d'une division entière.

Equality(BigInteger, BigInteger)

Retourne une valeur qui indique si les valeurs de deux objets BigInteger sont égales.

Equality(BigInteger, Int64)

Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long signé sont égales.

Equality(BigInteger, UInt64)

Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long non signé sont égales.

Equality(Int64, BigInteger)

Retourne une valeur qui indique si la valeur d'un entier long signé et la valeur BigInteger sont égales.

Equality(UInt64, BigInteger)

Retourne une valeur qui indique si la valeur d'un entier long non signé et la valeur BigInteger sont égales.

ExclusiveOr(BigInteger, BigInteger)

Effectue une opération de bits Or (XOr) exclusive sur deux valeurs BigInteger.

Explicit(BigInteger to Byte)

Définit une conversion explicite d'un objet BigInteger en valeur d'octet non signée.

Explicit(BigInteger to Decimal)

Définit une conversion explicite d'un objet BigInteger en valeur Decimal.

Explicit(BigInteger to Double)

Définit une conversion explicite d'un objet BigInteger en valeur Double.

Explicit(BigInteger to Int16)

Définit une conversion explicite d'un objet BigInteger en valeur d'entier 16 bits signé.

Explicit(BigInteger to Int32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits signé.

Explicit(BigInteger to Int64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits signé.

Explicit(BigInteger to SByte)

Définit une conversion explicite d'un objet BigInteger en valeur 8 bits signée.

Cette API n'est pas conforme CLS. L’alternative conforme est Int16.

Explicit(BigInteger to Single)

Définit une conversion explicite d'un objet BigInteger en valeur à virgule flottante simple précision.

Explicit(BigInteger to UInt16)

Définit une conversion explicite d'un objet BigInteger en valeur entière 16 bits non signée.

Cette API n'est pas conforme CLS. L’alternative conforme est Int32.

Explicit(BigInteger to UInt32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits non signé.

Cette API n'est pas conforme CLS. L’alternative conforme est Int64.

Explicit(BigInteger to UInt64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits non signé.

Cette API n'est pas conforme CLS. L’alternative conforme est Double.

Explicit(Decimal to BigInteger)

Définit une conversion explicite d'un objet Decimal en valeur BigInteger.

Explicit(Double to BigInteger)

Définit une conversion explicite d'une valeur Double en valeur BigInteger.

Explicit(Single to BigInteger)

Définit une conversion explicite d'une valeur Single en valeur BigInteger.

GreaterThan(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à une autre valeur BigInteger.

GreaterThan(BigInteger, Int64)

Retourne une valeur qui indique si BigInteger est supérieur à une valeur d'entier 64 bits signé.

GreaterThan(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier 64 bits non signé.

GreaterThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est supérieur à une valeur BigInteger.

GreaterThan(UInt64, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier 64 bits non signé.

GreaterThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une autre valeur BigInteger.

GreaterThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur d'entier 64 bits signé.

GreaterThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur entière 64 bits non signée.

GreaterThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est supérieur ou égal à une valeur BigInteger.

GreaterThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est supérieur ou égal à une valeur BigInteger.

Implicit(Byte to BigInteger)

Définit une conversion implicite d'un octet non signé en valeur BigInteger.

Implicit(Int16 to BigInteger)

Définit une conversion implicite d'un entier 16 bits signé en valeur BigInteger.

Implicit(Int32 to BigInteger)

Définit une conversion implicite d’un entier 32 bits signé en valeur BigInteger.

Implicit(Int64 to BigInteger)

Définit une conversion implicite d’un entier 64 bits signé en valeur BigInteger.

Implicit(SByte to BigInteger)

Définit une conversion implicite d'un entier 8 bits signé en valeur BigInteger.

Cette API n'est pas conforme CLS. L’alternative conforme est BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Définit une conversion implicite d'un entier 16 bits non signé en valeur BigInteger.

Cette API n'est pas conforme CLS. L’alternative conforme est Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Définit une conversion implicite d’un entier 32 bits non signé en valeur BigInteger.

Cette API n'est pas conforme CLS. L’alternative conforme est Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Définit une conversion implicite d’un entier 64 bits non signé en valeur BigInteger.

Cette API n'est pas conforme CLS. L’alternative conforme est Double.

Increment(BigInteger)

Incrémente une valeur BigInteger de 1.

Inequality(BigInteger, BigInteger)

Retourne une valeur qui indique si deux objets BigInteger ont des valeurs différentes.

Inequality(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger et un entier 64 bits signé ne sont pas égaux.

Inequality(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger et un entier 64 bits non signé ne sont pas égaux.

Inequality(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé et une valeur BigInteger ne sont pas égaux.

Inequality(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé et une valeur BigInteger ne sont pas égaux.

LeftShift(BigInteger, Int32)

Décale une valeur BigInteger d'un certain nombre de bits vers la gauche.

LessThan(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à une autre valeur BigInteger.

LessThan(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier 64 bits signé.

LessThan(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier 64 bits non signé.

LessThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est inférieur à une valeur BigInteger.

LessThan(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est inférieur à une valeur BigInteger.

LessThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à une autre valeur BigInteger.

LessThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier 64 bits signé.

LessThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier 64 bits non signé.

LessThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est inférieur ou égal à une valeur BigInteger.

LessThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est inférieur ou égal à une valeur BigInteger.

Modulus(BigInteger, BigInteger)

Retourne le modulo de la division de deux valeurs BigInteger spécifiques.

Multiply(BigInteger, BigInteger)

Multiplie deux valeurs BigInteger spécifiées.

OnesComplement(BigInteger)

Retourne le complément à un au niveau du bit d'une valeur BigInteger.

RightShift(BigInteger, Int32)

Décale une valeur BigInteger d’un certain nombre de bits vers la droite.

Subtraction(BigInteger, BigInteger)

Soustrait une valeur BigInteger d'une autre valeur BigInteger.

UnaryNegation(BigInteger)

Rend négative la valeur BigInteger spécifiée.

UnaryPlus(BigInteger)

Retourne la valeur de l'opérande BigInteger. (Le signe de l’opérande est inchangé.)

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.

S’applique à