BigInteger Constructeurs

Référence

Définition

Espace de noms:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Initialise une nouvelle instance de la structure BigInteger.

Surcharges

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(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.
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(Byte[])

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

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

public:
 BigInteger(cli::array <System::Byte> ^ value);

[System.CLSCompliant(false)]
public BigInteger (byte[] value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger

Public Sub New (value As Byte())

Paramètres

value: Byte[]

Tableau de valeurs d'octets respectant un ordre avec primauté des octets de poids faible (little-endian).

Attributs: CLSCompliantAttribute

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant instancie un BigInteger objet à partir d’un tableau d’octets à 5 éléments dont la valeur est {5, 4, 3, 2, 1}. Il affiche ensuite la BigInteger valeur, représentée sous forme de nombres décimaux et hexadécimaux, dans la console. Une comparaison du tableau d’entrée avec la sortie de texte indique clairement pourquoi cette surcharge du constructeur de classe crée un BigInteger objet dont la BigInteger valeur est 4328719365 (ou 0x102030405). Le premier élément du tableau d’octets, dont la valeur est 5, définit la valeur de l’octet d’ordre le plus bas de l’objet BigInteger , qui est 0x05. Le deuxième élément du tableau d’octets, dont la valeur est 4, définit la valeur du deuxième octet de l’objet BigInteger , qui est 0x04, et ainsi de suite.

byte[] bytes = { 5, 4, 3, 2, 1 };
BigInteger number = new BigInteger(bytes);
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number);
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

let bytes = [| 5uy; 4uy; 3uy; 2uy; 1uy |]
let number = new BigInteger(bytes)
printfn $"The value of number is {number} (or 0x{number:x})."
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

Dim bytes() As Byte = { 5, 4, 3, 2, 1 }
Dim number As New BigInteger(bytes)
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number) 
' The example displays the following output:
'    The value of number is 4328719365 (or 0x102030405).

L’exemple suivant instancie une valeur positive et une valeur négative BigInteger , les transmet à la ToByteArray méthode, puis restaure les valeurs d’origine BigInteger à partir du tableau d’octets résultant. Notez que les deux valeurs sont représentées par des tableaux d’octets identiques. La seule différence entre eux réside dans le bit le plus significatif du dernier élément du tableau d’octets. Ce bit est défini (la valeur de l’octet est 0xFF) si le tableau est créé à partir d’une valeur négative BigInteger . Le bit n’est pas défini (la valeur de l’octet est zéro), si le tableau est créé à partir d’une valeur positive BigInteger .

// Instantiate BigInteger values.
BigInteger positiveValue = BigInteger.Parse("4713143110832790377889");
BigInteger negativeValue = BigInteger.Add(-Int64.MaxValue, -60000);
BigInteger positiveValue2, negativeValue2;

// Create two byte arrays.
byte[] positiveBytes = positiveValue.ToByteArray();
byte[] negativeBytes = negativeValue.ToByteArray();

// Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue);
foreach (byte byteValue in negativeBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue2 = new BigInteger(negativeBytes);
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2);
Console.WriteLine();

// Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue);
foreach (byte byteValue in positiveBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue2 = new BigInteger(positiveBytes);
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2);
Console.WriteLine();
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

// Instantiate BigInteger values.
let positiveValue = BigInteger.Parse "4713143110832790377889"
let negativeValue = BigInteger.Add(-Int64.MaxValue, -60000)

// Create two byte arrays.
let positiveBytes = positiveValue.ToByteArray()
let negativeBytes = negativeValue.ToByteArray()

// Instantiate new BigInteger from negativeBytes array.
printf $"Converted {negativeValue:N0} to the byte array "

for byteValue in negativeBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let negativeValue2 = bigint negativeBytes
printfn $"Converted the byte array to {negativeValue2:N0}"
printfn ""

// Instantiate new BigInteger from positiveBytes array.
printf $"Converted {positiveValue:N0} to the byte array "

for byteValue in positiveBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let positiveValue2 = new BigInteger(positiveBytes)
printfn $"Converted the byte array to {positiveValue2:N0}"
printfn ""
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

' Instantiate BigInteger values.
Dim positiveValue As BigInteger = BigInteger.Parse("4713143110832790377889")
Dim negativeValue As BigInteger = BigInteger.Add(-Int64.MaxValue, -60000) 
Dim positiveValue2, negativeValue2 As BigInteger

' Create two byte arrays.
Dim positiveBytes() As Byte = positiveValue.ToByteArray()
Dim negativeBytes() As Byte = negativeValue.ToByteArray()

' Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue)
For Each byteValue As Byte In negativeBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
negativeValue2 = New BigInteger(negativeBytes)
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2)
Console.WriteLine()

' Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue)
For Each byteValue As Byte In positiveBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
positiveValue2 = New BigInteger(positiveBytes)
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2)
Console.WriteLine()
' The example displays the following output:
'    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
'    Converted the byte array to -9,223,372,036,854,835,807
'    
'    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
'    Converted the byte array to 4,713,143,110,832,790,377,889

L’exemple suivant montre comment s’assurer qu’une valeur positive n’est pas instanciée à tort en tant que valeur négative en ajoutant un octet dont la valeur est égale à zéro à la fin du tableau.

ulong originalNumber = UInt64.MaxValue;
byte[] bytes = BitConverter.GetBytes(originalNumber);
if (originalNumber > 0 && (bytes[bytes.Length - 1] & 0x80) > 0)
{
   byte[] temp = new byte[bytes.Length];
   Array.Copy(bytes, temp, bytes.Length);
   bytes = new byte[temp.Length + 1];
   Array.Copy(temp, bytes, temp.Length);
}

BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.",
                  originalNumber, newNumber);
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

let originalNumber = UInt64.MaxValue
let mutable bytes = BitConverter.GetBytes originalNumber

if originalNumber > 0uL && (bytes[bytes.Length - 1] &&& 0x80uy) > 0uy then
    let temp = Array.zeroCreate bytes.Length

    Array.Copy(bytes, temp, bytes.Length)
    bytes <- Array.zeroCreate (temp.Length + 1)
    Array.Copy(temp, bytes, temp.Length)

let newNumber = bigint bytes
printfn $"Converted the UInt64 value {originalNumber:N0} to {newNumber:N0}."
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Dim originalNumber As ULong = UInt64.MaxValue
' Convert an unsigned integer to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalNumber)
' Determine whether the MSB of the highest-order byte is set.
If originalNumber > 0 And (bytes(bytes.Length - 1) And &h80) > 0 Then
   ' If the MSB is set, add one zero-value byte to the end of the array.
   ReDim Preserve bytes(bytes.Length)
End If

Dim newNumber As New BigInteger(bytes)
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.", 
                  originalNumber, newNumber) 
' The example displays the following output:
'    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Remarques

Les octets individuels du tableau doivent être dans l’ordre value de petite taille, de l’octet d’ordre le plus bas à l’octet d’ordre le plus élevé. Par exemple, la valeur numérique 1 000 000 000 000 est représentée comme indiqué dans le tableau suivant :


Chaîne hexadécimale	E8D4A51000
Tableau d’octets (index le plus bas en premier)	00 10 A5 D4 E8 00

La plupart des méthodes qui convertissent des valeurs numériques en tableaux d’octets, telles que BigInteger.ToByteArray et BitConverter.GetBytes, retournent des tableaux d’octets dans un ordre peu endien.

Le constructeur s’attend à ce que les valeurs positives dans le tableau d’octets utilisent une représentation de signe et de magnitude, et que les valeurs négatives utilisent la représentation complémentaire de deux. En d’autres termes, si le bit d’ordre le plus élevé de l’octet d’ordre le plus élevé dans value est défini, la valeur résultante BigInteger est négative. Selon la source du tableau d’octets, une valeur positive peut être mal interprétée comme une valeur négative. Les tableaux d’octets sont généralement générés de la manière suivante :

En appelant la BigInteger.ToByteArray méthode . Étant donné que cette méthode retourne un tableau d’octets avec le bit d’ordre le plus élevé de l’octet d’ordre le plus élevé dans le tableau défini sur zéro pour les valeurs positives, il n’y a aucun risque de mal interpréter une valeur positive comme négative. Les tableaux d’octets non modifiés créés par la ToByteArray méthode effectuent toujours un aller-retour réussi lorsqu’ils sont transmis au BigInteger(Byte[]) constructeur.
En appelant la BitConverter.GetBytes méthode et en lui transmettant un entier signé en tant que paramètre. Étant donné que les entiers signés gèrent à la fois la représentation de signe et de magnitude et la représentation complémentaire de deux, il n’y a aucun risque de mal interpréter une valeur positive comme négative.
En appelant la BitConverter.GetBytes méthode et en lui transmettant un entier non signé en tant que paramètre. Étant donné que les entiers non signés sont représentés uniquement par leur magnitude, les valeurs positives peuvent être mal interprétées comme des valeurs négatives. Pour éviter cette mauvaise interprétation, vous pouvez ajouter une valeur de zéro octet à la fin du tableau. L’exemple de la section suivante fournit une illustration.
En créant un tableau d’octets dynamiquement ou statiquement sans nécessairement appeler l’une des méthodes précédentes, ou en modifiant un tableau d’octets existant. Pour éviter que les valeurs positives ne soient mal interprétées comme des valeurs négatives, vous pouvez ajouter une valeur de zéro octet à la fin du tableau.

Si value est un tableau vide Byte , le nouvel BigInteger objet est initialisé à une valeur de BigInteger.Zero. Si value est null, le constructeur lève un ArgumentNullException.

Voir aussi

ToByteArray()

S’applique à

BigInteger(Decimal)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 BigInteger(System::Decimal value);

public BigInteger (decimal value);

new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger

Public Sub New (value As Decimal)

Paramètres

value: Decimal

Nombre décimal.

Exemples

L’exemple suivant illustre l’utilisation du BigInteger(Decimal) constructeur pour instancier un BigInteger objet. Il définit un tableau de Decimal valeurs, puis passe chaque valeur au BigInteger(Decimal) constructeur. Notez que la Decimal valeur est tronquée au lieu d’être arrondie lorsqu’elle est affectée à l’objet BigInteger .

decimal[] decimalValues = { -1790.533m, -15.1514m, 18903.79m, 9180098.003m };
foreach (decimal decimalValue in decimalValues)
{
   BigInteger number = new BigInteger(decimalValue);
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue);
}
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

let decimalValues = [ -1790.533m; -15.1514m; 18903.79m; 9180098.003m ]

for decimalValue in decimalValues do
    let number = bigint decimalValue
    printfn $"Instantiated BigInteger value {number} from the Decimal value {decimalValue}."
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Dim decimalValues() As Decimal = { -1790.533d, -15.1514d, 18903.79d, 9180098.003d }
For Each decimalValue As Decimal In decimalValues
   Dim number As New BigInteger(decimalValue)
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue)
Next                 
' The example displays the following output:
'    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
'    Instantiated BigInteger value -15 from the Decimal value -15.1514.
'    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
'    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Remarques

Le résultat de l’appel de ce constructeur est identique à l’attribution explicite d’une Decimal valeur à une BigInteger variable.

L’appel de ce constructeur peut entraîner une perte de données ; toute partie fractionnaire de est tronquée lors de value l’instanciation d’un BigInteger objet.

S’applique à

BigInteger(Double)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 BigInteger(double value);

public BigInteger (double value);

new System.Numerics.BigInteger : double -> System.Numerics.BigInteger

Public Sub New (value As Double)

Paramètres

value: Double

Valeur à virgule flottante double précision.

Exceptions

OverflowException

value a la valeur NaN, NegativeInfinity ou PositiveInfinity.

Exemples

L’exemple suivant illustre l’utilisation du BigInteger(Double) constructeur pour instancier un BigInteger objet. Il illustre également la perte de précision qui peut se produire lorsque vous utilisez le type de Double données. A Double se voit attribuer une grande valeur, qui est ensuite affectée à un BigInteger objet. Comme le montre la sortie, cette affectation implique une perte de précision. Les deux valeurs sont ensuite incrémentées d’une. La sortie indique que l’objet BigInteger reflète la valeur modifiée, contrairement à l’objet Double .

// Create a BigInteger from a large double value.
double doubleValue = -6e20;
BigInteger bigIntValue = new BigInteger(doubleValue);
Console.WriteLine("Original Double value: {0:N0}", doubleValue);
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue);
// Increment and then display both values.
doubleValue++;
bigIntValue += BigInteger.One;
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue);
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue);
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

// Create a BigInteger from a large double value.
let doubleValue = -6e20
let bigIntValue = bigint doubleValue
printfn $"Original Double value: {doubleValue:N0}"
printfn $"Original BigInteger value: {bigIntValue:N0}"
// Increment and then display both values.
let doubleValue = doubleValue + 1.
let bigIntValue = bigIntValue + BigInteger.One
printfn $"Incremented Double value: {doubleValue:N0}"
printfn $"Incremented BigInteger value: {bigIntValue:N0}"
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

' Create a BigInteger from a large double value.
Dim doubleValue As Double = -6e20
Dim bigIntValue As New BigInteger(doubleValue)
Console.WriteLine("Original Double value: {0:N0}", doubleValue)
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue)
' Increment and then display both values.
doubleValue += 1
bigIntValue += BigInteger.One
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue)
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue)
' The example displays the following output:
'    Original Double value: -600,000,000,000,000,000,000
'    Original BigInteger value: -600,000,000,000,000,000,000
'    Incremented Double value: -600,000,000,000,000,000,000
'    Incremented BigInteger value: -599,999,999,999,999,999,999

Remarques

Toute partie fractionnaire du paramètre est tronquée lors de l’instanciation value d’un BigInteger objet.

En raison du manque de précision du type de données, l’appel Double de ce constructeur peut entraîner une perte de données.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation explicite d’une Double valeur à un BigInteger.

S’applique à

BigInteger(Int32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 BigInteger(int value);

public BigInteger (int value);

new System.Numerics.BigInteger : int -> System.Numerics.BigInteger

Public Sub New (value As Integer)

Paramètres

value: Int32

Entier signé 32 bits.

Exemples

L’exemple suivant appelle le BigInteger(Int32) constructeur pour instancier des BigInteger valeurs à partir d’un tableau d’entiers 32 bits. Il utilise également la conversion implicite pour affecter chaque valeur entière 32 bits à une BigInteger variable. Il compare ensuite les deux valeurs pour établir que les valeurs résultantes BigInteger sont les mêmes.

int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                   Int32.MaxValue };
BigInteger constructed, assigned;

foreach (int number in integers)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

let integers = [ Int32.MinValue; -10534; -189; 0; 17; 113439; Int32.MaxValue ]

for number in integers do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

Dim integers() As Integer = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                              Int32.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Integer In integers
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -2147483648 = -2147483648: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       2147483647 = 2147483647: True

Remarques

Il n’y a aucune perte de précision lors de l’instanciation d’un BigInteger objet à l’aide de ce constructeur.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation d’une Int32 valeur à un BigInteger.

La BigInteger structure n’inclut pas les constructeurs avec un paramètre de type Byte, Int16, SByteou UInt16. Toutefois, le Int32 type prend en charge la conversion implicite d’entiers 8 bits et 16 bits signés et non signés en entiers 32 bits signés. Par conséquent, ce constructeur est appelé si value est l’un de ces quatre types intégraux.

S’applique à

BigInteger(Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 BigInteger(long value);

public BigInteger (long value);

new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger

Public Sub New (value As Long)

Paramètres

value: Int64

Entier signé 64 bits.

Exemples

L’exemple suivant appelle le BigInteger(Int64) constructeur pour instancier des BigInteger valeurs d’un tableau d’entiers 64 bits. Il utilise également la conversion implicite pour affecter chaque valeur entière 64 bits à une BigInteger variable. Il compare ensuite les deux valeurs pour établir que les valeurs résultantes BigInteger sont les mêmes.

long[] longs = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                 Int64.MaxValue };
BigInteger constructed, assigned;

foreach (long number in longs)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

let longs = [ Int64.MinValue; -10534; -189; 0; 17; 113439; Int64.MaxValue ]

for number in longs do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

Dim longs() As Long = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                              Int64.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Long In longs
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -2147483648 = -2147483648: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       2147483647 = 2147483647: True

Remarques

Il n’y a aucune perte de précision lors de l’instanciation d’un BigInteger objet à l’aide de ce constructeur.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation d’une Int64 valeur à un BigInteger.

S’applique à

BigInteger(Single)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 BigInteger(float value);

public BigInteger (float value);

new System.Numerics.BigInteger : single -> System.Numerics.BigInteger

Public Sub New (value As Single)

Paramètres

value: Single

Valeur à virgule flottante simple précision.

Exceptions

OverflowException

value a la valeur NaN, NegativeInfinity ou PositiveInfinity.

Exemples

L’exemple suivant illustre l’utilisation du BigInteger(Single) constructeur pour instancier un BigInteger objet. Il illustre également la perte de précision qui peut se produire lorsque vous utilisez le type de Single données. A Single se voit attribuer une grande valeur négative, qui est ensuite affectée à un BigInteger objet. Comme le montre la sortie, cette affectation entraîne une perte de précision. Les deux valeurs sont ensuite incrémentées d’une unité. La sortie indique que l’objet BigInteger reflète la valeur modifiée, contrairement à l’objet Single .

// Create a BigInteger from a large negative Single value
float negativeSingle = Single.MinValue;
BigInteger negativeNumber = new BigInteger(negativeSingle);

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));

negativeSingle++;
negativeNumber++;

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

// Create a BigInteger from a large negative Single value
let negativeSingle = Single.MinValue
let negativeNumber = bigint negativeSingle

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""

let negativeSingle = negativeSingle + 1f
let negativeNumber = negativeNumber + 1I

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

' Create a BigInteger from a large negative Single value
Dim negativeSingle As Single = Single.MinValue
Dim negativeNumber As New BigInteger(negativeSingle)

Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))

negativeSingle += 1
negativeNumber += 1
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
' The example displays the following output:
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,440
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,439

Remarques

Toute partie fractionnaire du paramètre est tronquée lors de l’instanciation value d’un BigInteger objet.

En raison du manque de précision du type de données, l’appel Single de ce constructeur peut entraîner une perte de données.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation explicite d’une Single valeur à un BigInteger.

S’applique à

BigInteger(UInt32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Numerics.BigInteger.BigInteger(Int64)

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

public:
 BigInteger(System::UInt32 value);

[System.CLSCompliant(false)]
public BigInteger (uint value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger

Public Sub New (value As UInteger)

Paramètres

value: UInt32

Valeur d'entier 32 bits non signé.

Attributs: CLSCompliantAttribute

Exemples

L’exemple suivant utilise le BigInteger(UInt32) constructeur et une instruction d’affectation pour initialiser BigInteger des valeurs à partir d’un tableau d’entiers 32 bits non signés. Il compare ensuite les deux valeurs pour démontrer que les deux méthodes d’initialisation d’une BigInteger valeur produisent des résultats identiques.

uint[] unsignedValues = { 0, 16704, 199365, UInt32.MaxValue };
foreach (uint unsignedValue in unsignedValues)
{
   BigInteger constructedNumber = new BigInteger(unsignedValue);
   BigInteger assignedNumber = unsignedValue;
   if (constructedNumber.Equals(assignedNumber))
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber);
   else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber);
}
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

let unsignedValues = [ 0u; 16704u; 199365u; UInt32.MaxValue ]

for unsignedValue in unsignedValues do
    let constructedNumber = bigint unsignedValue
    let assignedNumber = unsignedValue

    if constructedNumber.Equals assignedNumber then
        printfn $"Both methods create a BigInteger whose value is {constructedNumber:N0}."
    else
        printfn $"{constructedNumber:N0} ≠ {assignedNumber:N0}"
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

Dim unsignedValues() As UInteger = { 0, 16704, 199365, UInt32.MaxValue }
For Each unsignedValue As UInteger In unsignedValues
   Dim constructedNumber As New BigInteger(unsignedValue)
   Dim assignedNumber As BigInteger = unsignedValue
   If constructedNumber.Equals(assignedNumber) Then
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber)
   Else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber)
   End If                         
Next
' The example displays the following output:
'    Both methods create a BigInteger whose value is 0.
'    Both methods create a BigInteger whose value is 16,704.
'    Both methods create a BigInteger whose value is 199,365.
'    Both methods create a BigInteger whose value is 4,294,967,295.

Remarques

Il n’y a aucune perte de précision lors de l’instanciation d’un BigInteger à l’aide de ce constructeur.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation d’une UInt32 valeur à un BigInteger.

S’applique à

BigInteger(UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Numerics.BigInteger.BigInteger(Double)

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

public:
 BigInteger(System::UInt64 value);

[System.CLSCompliant(false)]
public BigInteger (ulong value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger

Public Sub New (value As ULong)

Paramètres

value: UInt64

Entier 64 bits non signé.

Attributs: CLSCompliantAttribute

Exemples

L’exemple suivant utilise le BigInteger(UInt64) constructeur pour instancier un BigInteger objet dont la valeur est égale à MaxValue.

ulong unsignedValue = UInt64.MaxValue;
BigInteger number = new BigInteger(unsignedValue);
Console.WriteLine(number.ToString("N0"));
// The example displays the following output:
//       18,446,744,073,709,551,615

let unsignedValue = UInt64.MaxValue
let number = bigint unsignedValue
printfn $"{number:N0}"
// The example displays the following output:
//       18,446,744,073,709,551,615

Dim unsignedValue As ULong = UInt64.MaxValue
Dim number As New BigInteger(unsignedValue)
Console.WriteLine(number.ToString("N0"))       
' The example displays the following output:
'       18,446,744,073,709,551,615

Remarques

Il n’y a aucune perte de précision lors de l’instanciation d’un BigInteger à l’aide de ce constructeur.

La BigInteger valeur qui résulte de l’appel de ce constructeur est identique à la valeur qui résulte de l’affectation d’une UInt64 valeur à un BigInteger.

S’applique à

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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.

public BigInteger (ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);

new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigInteger

Public Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)

Paramètres

value: ReadOnlySpan<Byte>

Étendue en lecture seule d’octets représentant l’entier très grand.

isUnsigned: Boolean

true pour indiquer que value utilise l’encodage non signé ; sinon, false (valeur par défaut).

isBigEndian: Boolean

true pour indiquer est value dans l’ordre des octets big-endian ; sinon, false (valeur par défaut).

S’applique à

Partager via

BigInteger Constructeurs

Définition

Surcharges

BigInteger(Byte[])

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

BigInteger(Decimal)

Paramètres

Exemples

Remarques

S’applique à

BigInteger(Double)

Paramètres

Exceptions

Exemples

Remarques

S’applique à

BigInteger(Int32)

Paramètres

Exemples

Remarques

S’applique à

BigInteger(Int64)

Paramètres

Exemples

Remarques

S’applique à

BigInteger(Single)

Paramètres

Exceptions

Exemples

Remarques

S’applique à

BigInteger(UInt32)

Paramètres

Exemples

Remarques

S’applique à

BigInteger(UInt64)

Paramètres

Exemples

Remarques

S’applique à

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Paramètres

S’applique à

Ressources supplémentaires