BigInteger Costruttori

Definizione

Inizializza una nuova istanza della struttura BigInteger.Initializes a new instance of the BigInteger structure.

Overload

BigInteger(Byte[])

Inizializza una nuova istanza della struttura BigInteger utilizzando i valori di una matrice di byte.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione doppia.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

Inizializza una nuova istanza della struttura BigInteger utilizzando un Signed Integer a 32 bit.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

Inizializza una nuova istanza della struttura BigInteger usando un valore intero con segno a 64 bit.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione singola.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Unsigned Integer a 32 bit.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

Inizializza una nuova istanza della struttura BigInteger con un valore Unsigned Integer a 64 bit.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inizializza una nuova istanza della struttura BigInteger usando i valori in un intervallo di byte di sola lettura e indicando facoltativamente la codifica con firma e l'ordine dei byte.Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.

BigInteger(Byte[])

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della struttura BigInteger utilizzando i valori di una matrice di byte.Initializes a new instance of the BigInteger structure using the values in a byte array.

public:
 BigInteger(cli::array <System::Byte> ^ value);
[System.CLSCompliant(false)]
public BigInteger (byte[] value);
public BigInteger (byte[] value);
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger
Public Sub New (value As Byte())

Parametri

value
Byte[]

Matrice di valori byte in ordine little-endian.An array of byte values in little-endian order.

Attributi

Eccezioni

value è null.value is null.

Esempio

Nell'esempio seguente viene creata un'istanza di un oggetto BigInteger da una matrice di byte a 5 elementi il cui valore è {5, 4, 3, 2, 1}.The following example instantiates a BigInteger object from a 5-element byte array whose value is {5, 4, 3, 2, 1}. Viene quindi visualizzato nella console il valore BigInteger, rappresentato come numeri decimali ed esadecimali.It then displays the BigInteger value, represented as both decimal and hexadecimal numbers, to the console. Un confronto della matrice di input con l'output di testo rende chiaro il motivo per cui questo overload del costruttore della classe BigInteger crea un oggetto BigInteger il cui valore è 4328719365 (o 0x102030405).A comparison of the input array with the text output makes it clear why this overload of the BigInteger class constructor creates a BigInteger object whose value is 4328719365 (or 0x102030405). Il primo elemento della matrice di byte, il cui valore è 5, definisce il valore del byte di ordine più basso dell'oggetto BigInteger, ovvero 0x05.The first element of the byte array, whose value is 5, defines the value of the lowest-order byte of the BigInteger object, which is 0x05. Il secondo elemento della matrice di byte, il cui valore è 4, definisce il valore del secondo byte dell'oggetto BigInteger, ovvero 0x04, e così via.The second element of the byte array, whose value is 4, defines the value of the second byte of the BigInteger object, which is 0x04, and so on.

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

Nell'esempio seguente viene creata un'istanza di un valore BigInteger positivo e negativo, vengono passati al metodo ToByteArray, quindi vengono ripristinati i valori di BigInteger originali dalla matrice di byte risultante.The following example instantiates a positive and a negative BigInteger value, passes them to the ToByteArray method, and then restores the original BigInteger values from the resulting byte array. Si noti che i due valori sono rappresentati da matrici di byte identiche.Note that the two values are represented by identical byte arrays. L'unica differenza tra di essi è il bit più significativo dell'ultimo elemento nella matrice di byte.The only difference between them is in the most significant bit of the last element in the byte array. Questo bit è impostato (il valore del byte è 0xFF) se la matrice viene creata da un valore di BigInteger negativo.This bit is set (the value of the byte is 0xFF) if the array is created from a negative BigInteger value. Il bit non è impostato (il valore del byte è zero), se la matrice viene creata da un valore di BigInteger positivo.The bit is not set (the value of the byte is zero), if the array is created from a positive BigInteger value.

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

Nell'esempio riportato di seguito viene illustrato come verificare che un valore positivo non venga creato in modo errato come valore negativo aggiungendo un byte il cui valore è pari a zero alla fine della matrice.The following example illustrates how to make sure that a positive value is not incorrectly instantiated as a negative value by adding a byte whose value is zero to the end of the array.

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.

Commenti

I singoli byte nella matrice value devono essere in ordine little-endian, dal byte di ordine più basso a quello più alto.The individual bytes in the value array should be in little-endian order, from lowest-order byte to highest-order byte. Il valore numerico 1 mille miliardi, ad esempio, è rappresentato come illustrato nella tabella seguente:For example, the numeric value 1,000,000,000,000 is represented as shown in the following table:

Stringa esadecimaleHexadecimal string E8D4A51000E8D4A51000
Array di byte (prima indice più basso)Byte array (lowest index first) 00 10 A5 D4 E8 0000 10 A5 D4 E8 00

La maggior parte dei metodi che convertono i valori numerici in matrici di byte, ad esempio BigInteger.ToByteArray e BitConverter.GetBytes, restituiscono matrici di byte in ordine little-endian.Most methods that convert numeric values to byte arrays, such as BigInteger.ToByteArray and BitConverter.GetBytes, return byte arrays in little-endian order.

Il costruttore prevede che i valori positivi nella matrice di byte usino la rappresentazione di segno e grandezza e i valori negativi per usare la rappresentazione in complemento a due.The constructor expects positive values in the byte array to use sign-and-magnitude representation, and negative values to use two's complement representation. In altre parole, se viene impostato il bit di ordine più alto del byte più elevato in value, il valore di BigInteger risultante è negativo.In other words, if the highest-order bit of the highest-order byte in value is set, the resulting BigInteger value is negative. A seconda dell'origine della matrice di byte, è possibile che un valore positivo venga interpretato erroneamente come un valore negativo.Depending on the source of the byte array, this may cause a positive value to be misinterpreted as a negative value. Le matrici di byte vengono in genere generate nei modi seguenti:Byte arrays are typically generated in the following ways:

  • Chiamando il metodo BigInteger.ToByteArray.By calling the BigInteger.ToByteArray method. Poiché questo metodo restituisce una matrice di byte con il bit di ordine più alto del byte più elevato nella matrice impostata su zero per i valori positivi, non è possibile interpretare erroneamente un valore positivo come negativo.Because this method returns a byte array with the highest-order bit of the highest-order byte in the array set to zero for positive values, there is no chance of misinterpreting a positive value as negative. Le matrici di byte non modificate create dal metodo ToByteArray hanno sempre eseguito il round trip quando vengono passate al costruttore di BigInteger(Byte[]).Unmodified byte arrays created by the ToByteArray method always successfully round-trip when they are passed to the BigInteger(Byte[]) constructor.

  • Chiamando il metodo BitConverter.GetBytes e passandogli un intero con segno come parametro.By calling the BitConverter.GetBytes method and passing it a signed integer as a parameter. Poiché gli interi con segno gestiscono sia la rappresentazione di firma che la rappresentazione in complemento a due, non è possibile interpretare erroneamente un valore positivo come negativo.Because signed integers handle both sign-and-magnitude representation and two's complement representation, there is no chance of misinterpreting a positive value as negative.

  • Chiamando il metodo BitConverter.GetBytes e passandogli una Unsigned Integer come parametro.By calling the BitConverter.GetBytes method and passing it an unsigned integer as a parameter. Poiché gli Integer senza segno sono rappresentati solo dalla loro grandezza, i valori positivi possono essere interpretati erroneamente come valori negativi.Because unsigned integers are represented by their magnitude only, positive values can be misinterpreted as negative values. Per evitare questa interpretazione errata, è possibile aggiungere un valore a zero byte alla fine della matrice.To prevent this misinterpretation, you can add a zero-byte value to the end of the array. Nell'esempio riportato nella sezione successiva viene illustrato.The example in the next section provides an illustration.

  • Creando una matrice di byte in modo dinamico o statico senza chiamare necessariamente uno dei metodi precedenti oppure modificando una matrice di byte esistente.By creating a byte array either dynamically or statically without necessarily calling any of the previous methods, or by modifying an existing byte array. Per impedire che i valori positivi vengano erroneamente interpretati come valori negativi, è possibile aggiungere un valore a zero byte alla fine della matrice.To prevent positive values from being misinterpreted as negative values, you can add a zero-byte value to the end of the array.

Se value è una matrice di Byte vuota, il nuovo oggetto BigInteger viene inizializzato su un valore di BigInteger.Zero.If value is an empty Byte array, the new BigInteger object is initialized to a value of BigInteger.Zero. Se value è null, il costruttore genera un ArgumentNullException.If value is null, the constructor throws an ArgumentNullException.

Vedi anche

BigInteger(Decimal)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

public:
 BigInteger(System::Decimal value);
public BigInteger (decimal value);
new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger
Public Sub New (value As Decimal)

Parametri

value
Decimal

Numero decimale.A decimal number.

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del costruttore BigInteger(Decimal) per creare un'istanza di un oggetto BigInteger.The following example illustrates the use of the BigInteger(Decimal) constructor to instantiate a BigInteger object. Definisce una matrice di valori di Decimal, quindi passa ogni valore al costruttore di BigInteger(Decimal).It defines an array of Decimal values, and then passes each value to the BigInteger(Decimal) constructor. Si noti che il valore Decimal viene troncato anziché arrotondato quando viene assegnato all'oggetto BigInteger.Note that the Decimal value is truncated instead of rounded when it is assigned to the BigInteger object.

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.

Commenti

Il risultato della chiamata a questo costruttore è identico a assegnare in modo esplicito un valore Decimal a una variabile BigInteger.The result of calling this constructor is identical to explicitly assigning a Decimal value to a BigInteger variable.

La chiamata di questo costruttore può causare la perdita di dati. una parte frazionaria di value viene troncata quando si crea un'istanza di un oggetto BigInteger.Calling this constructor can cause data loss; any fractional part of value is truncated when instantiating a BigInteger object.

BigInteger(Double)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione doppia.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

public:
 BigInteger(double value);
public BigInteger (double value);
new System.Numerics.BigInteger : double -> System.Numerics.BigInteger
Public Sub New (value As Double)

Parametri

value
Double

Valore a virgola mobile con precisione doppia.A double-precision floating-point value.

Eccezioni

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del costruttore BigInteger(Double) per creare un'istanza di un oggetto BigInteger.The following example illustrates the use of the BigInteger(Double) constructor to instantiate a BigInteger object. Viene inoltre illustrata la perdita di precisione che può verificarsi quando si utilizza il tipo di dati Double.It also illustrates the loss of precision that may occur when you use the Double data type. A un Double viene assegnato un valore di grandi dimensioni, che viene quindi assegnato a un oggetto BigInteger.A Double is assigned a large value, which is then assigned to a BigInteger object. Come mostra l'output, questa assegnazione comporta una perdita di precisione.As the output shows, this assignment involves a loss of precision. Entrambi i valori vengono incrementati di uno.Both values are then incremented by one. L'output mostra che l'oggetto BigInteger riflette il valore modificato, mentre l'oggetto Double non lo è.The output shows that the BigInteger object reflects the changed value, whereas the Double object does not.

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

Commenti

Una parte frazionaria del parametro value viene troncata quando si crea un'istanza di un oggetto BigInteger.Any fractional part of the value parameter is truncated when instantiating a BigInteger object.

A causa della mancanza di precisione del tipo di dati Double, la chiamata di questo costruttore può causare la perdita di dati.Because of the lack of precision of the Double data type, calling this constructor can cause data loss.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione esplicita di un valore Double a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Double value to a BigInteger.

BigInteger(Int32)

Inizializza una nuova istanza della struttura BigInteger utilizzando un Signed Integer a 32 bit.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

public:
 BigInteger(int value);
public BigInteger (int value);
new System.Numerics.BigInteger : int -> System.Numerics.BigInteger
Public Sub New (value As Integer)

Parametri

value
Int32

Intero con segno a 32 bit.A 32-bit signed integer.

Esempio

Nell'esempio seguente viene chiamato il costruttore BigInteger(Int32) per creare un'istanza dei valori BigInteger da una matrice di interi a 32 bit.The following example calls the BigInteger(Int32) constructor to instantiate BigInteger values from an array of 32-bit integers. USA anche la conversione implicita per assegnare ogni valore integer a 32 bit a una variabile BigInteger.It also uses implicit conversion to assign each 32-bit integer value to a BigInteger variable. Confronta quindi i due valori per stabilire che i valori di BigInteger risultanti sono uguali.It then compares the two values to establish that the resulting BigInteger values are the same.

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

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un oggetto BigInteger usando questo costruttore.There is no loss of precision when instantiating a BigInteger object by using this constructor.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un valore Int32 a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int32 value to a BigInteger.

La struttura BigInteger non include costruttori con un parametro di tipo Byte, Int16, SByteo UInt16.The BigInteger structure does not include constructors with a parameter of type Byte, Int16, SByte, or UInt16. Tuttavia, il tipo di Int32 supporta la conversione implicita di interi con segno a 8 bit e a 16 bit a interi con segno a 32 bit.However, the Int32 type supports the implicit conversion of 8-bit and 16-bit signed and unsigned integers to signed 32-bit integers. Di conseguenza, questo costruttore viene chiamato se value è uno di questi quattro tipi integrali.As a result, this constructor is called if value is any one of these four integral types.

BigInteger(Int64)

Inizializza una nuova istanza della struttura BigInteger usando un valore intero con segno a 64 bit.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

public:
 BigInteger(long value);
public BigInteger (long value);
new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger
Public Sub New (value As Long)

Parametri

value
Int64

Intero con segno a 64 bit.A 64-bit signed integer.

Esempio

Nell'esempio seguente viene chiamato il costruttore BigInteger(Int64) per creare un'istanza dei valori BigInteger da una matrice di interi a 64 bit.The following example calls the BigInteger(Int64) constructor to instantiate BigInteger values from an array of 64-bit integers. USA anche la conversione implicita per assegnare ogni valore integer a 64 bit a una variabile BigInteger.It also uses implicit conversion to assign each 64-bit integer value to a BigInteger variable. Confronta quindi i due valori per stabilire che i valori di BigInteger risultanti sono uguali.It then compares the two values to establish that the resulting BigInteger values are the same.

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

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un oggetto BigInteger usando questo costruttore.There is no loss of precision when instantiating a BigInteger object by using this constructor.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un valore Int64 a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int64 value to a BigInteger.

BigInteger(Single)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione singola.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

public:
 BigInteger(float value);
public BigInteger (float value);
new System.Numerics.BigInteger : single -> System.Numerics.BigInteger
Public Sub New (value As Single)

Parametri

value
Single

Valore a virgola mobile con precisione singola.A single-precision floating-point value.

Eccezioni

Esempio

Nell'esempio seguente viene illustrato l'utilizzo del costruttore BigInteger(Single) per creare un'istanza di un oggetto BigInteger.The following example illustrates the use of the BigInteger(Single) constructor to instantiate a BigInteger object. Viene inoltre illustrata la perdita di precisione che può verificarsi quando si utilizza il tipo di dati Single.It also illustrates the loss of precision that may occur when you use the Single data type. A un Single viene assegnato un valore negativo di grandi dimensioni, che viene quindi assegnato a un oggetto BigInteger.A Single is assigned a large negative value, which is then assigned to a BigInteger object. Come mostra l'output, questa assegnazione comporta una perdita di precisione.As the output shows, this assignment involves a loss of precision. Entrambi i valori vengono incrementati di uno.Both values are then incremented by one. L'output mostra che l'oggetto BigInteger riflette il valore modificato, mentre l'oggetto Single non lo è.The output shows that the BigInteger object reflects the changed value, whereas the Single object does not.

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

Commenti

Una parte frazionaria del parametro value viene troncata quando si crea un'istanza di un oggetto BigInteger.Any fractional part of the value parameter is truncated when instantiating a BigInteger object.

A causa della mancanza di precisione del tipo di dati Single, la chiamata di questo costruttore può causare la perdita di dati.Because of the lack of precision of the Single data type, calling this constructor can result in data loss.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione esplicita di un valore Single a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Single value to a BigInteger.

BigInteger(UInt32)

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS
System.Numerics.BigInteger.BigInteger(Int64)

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Unsigned Integer a 32 bit.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

public:
 BigInteger(System::UInt32 value);
[System.CLSCompliant(false)]
public BigInteger (uint value);
public BigInteger (uint value);
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger
Public Sub New (value As UInteger)

Parametri

value
UInt32

Valore intero senza segno a 32 bit.An unsigned 32-bit integer value.

Attributi

Esempio

Nell'esempio seguente vengono utilizzati il costruttore BigInteger(UInt32) e un'istruzione di assegnazione per inizializzare i valori di BigInteger da una matrice di interi senza segno a 32 bit.The following example uses the BigInteger(UInt32) constructor and an assignment statement to initialize BigInteger values from an array of unsigned 32-bit integers. Vengono quindi confrontati i due valori per dimostrare che i due metodi di inizializzazione di un valore di BigInteger producono risultati identici.It then compares the two values to demonstrate that the two methods of initializing a BigInteger value produce identical results.

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.

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un BigInteger utilizzando questo costruttore.There is no loss of precision when instantiating a BigInteger using this constructor.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un valore UInt32 a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt32 value to a BigInteger.

BigInteger(UInt64)

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS
System.Numerics.BigInteger.BigInteger(Double)

Inizializza una nuova istanza della struttura BigInteger con un valore Unsigned Integer a 64 bit.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

public:
 BigInteger(System::UInt64 value);
[System.CLSCompliant(false)]
public BigInteger (ulong value);
public BigInteger (ulong value);
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger
Public Sub New (value As ULong)

Parametri

value
UInt64

Intero senza segno a 64 bit.An unsigned 64-bit integer.

Attributi

Esempio

Nell'esempio seguente viene usato il costruttore BigInteger(UInt64) per creare un'istanza di un oggetto BigInteger il cui valore è uguale a MaxValue.The following example uses the BigInteger(UInt64) constructor to instantiate a BigInteger object whose value is equal to 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      

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un BigInteger utilizzando questo costruttore.There is no loss of precision when instantiating a BigInteger using this constructor.

Il valore BigInteger risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un valore UInt64 a un BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt64 value to a BigInteger.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inizializza una nuova istanza della struttura BigInteger usando i valori in un intervallo di byte di sola lettura e indicando facoltativamente la codifica con firma e l'ordine dei byte.Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.

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)

Parametri

value
ReadOnlySpan<Byte>

Intervallo di byte di sola lettura che rappresentano i dati big integer.A read-only span of bytes representing the big integer.

isUnsigned
Boolean

true per indicare che value usa la codifica senza segno; in caso contrario, false (valore predefinito).true to indicate value uses unsigned encoding; otherwise, false (the default value).

isBigEndian
Boolean

true per indicare che value è nell'ordine dei byte big endian; in caso contrario, false (valore predefinito).true to indicate value is in big-endian byte order; otherwise, false (the default value).

Si applica a