BigInteger Constructeurs

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

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

Attributs

CLSCompliantAttribute

Exceptions

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

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

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 :

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

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

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

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.

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.

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

public:
 BigInteger(double value);

public BigInteger (double value);

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

Public Sub New (value As Double)

Paramètres

Exceptions

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

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

public:
 BigInteger(int value);

public BigInteger (int value);

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

Public Sub New (value As Integer)

Paramètres

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

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.

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

public:
 BigInteger(long value);

public BigInteger (long value);

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

Public Sub New (value As Long)

Paramètres

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

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.

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

public:
 BigInteger(float value);

public BigInteger (float value);

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

Public Sub New (value As Single)

Paramètres

Exceptions

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

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

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

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant utilise le BigInteger(UInt32) constructeur et une instruction d’affectation pour initialiser des BigInteger 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.

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.

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

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

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

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.

Source:

BigInteger.cs

Source:

BigInteger.cs

Source:

BigInteger.cs

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