BigInteger Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza una nuova istanza della struttura BigInteger.

Overload

BigInteger(Byte[])	Inizializza una nuova istanza della struttura BigInteger utilizzando i valori di una matrice di byte.
BigInteger(Decimal)	Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Decimal.
BigInteger(Double)	Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione doppia.
BigInteger(Int32)	Inizializza una nuova istanza della struttura BigInteger utilizzando un Signed Integer a 32 bit.
BigInteger(Int64)	Inizializza una nuova istanza della struttura BigInteger usando un valore intero con segno a 64 bit.
BigInteger(Single)	Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione singola.
BigInteger(UInt32)	Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Unsigned Integer a 32 bit.
BigInteger(UInt64)	Inizializza una nuova istanza della struttura BigInteger con un valore Unsigned Integer a 64 bit.
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.

BigInteger(Byte[])

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della struttura BigInteger utilizzando i valori di una matrice di byte.

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

Parametri

value: Byte[]

Matrice di valori byte in ordine little-endian.

Attributi: CLSCompliantAttribute

Eccezioni

ArgumentNullException

value è null.

Esempio

Nell'esempio seguente viene creata un'istanza di un BigInteger oggetto da una matrice di byte a 5 elementi il cui valore è {5, 4, 3, 2, 1}. Visualizza quindi il BigInteger valore, rappresentato sia come numeri decimali che esadecimali, nella console. Un confronto tra la matrice di input e l'output di testo rende chiaro il motivo per cui questo overload del BigInteger costruttore della classe crea un BigInteger oggetto il cui valore è 4328719365 (o 0x102030405). Il primo elemento della matrice di byte, il cui valore è 5, definisce il valore del byte di ordine più basso dell'oggetto BigInteger , che è 0x05. Il secondo elemento della matrice di byte, il cui valore è 4, definisce il valore del secondo byte dell'oggetto BigInteger , che è 0x04 e così via.

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'esempio seguente crea un'istanza di un valore positivo e negativo BigInteger , li passa al ToByteArray metodo e quindi ripristina i valori originali BigInteger dalla matrice di byte risultante. Si noti che i due valori sono rappresentati da matrici di byte identiche. L'unica differenza tra di esse è il bit più significativo dell'ultimo elemento nella matrice di byte. Questo bit viene impostato (il valore del byte è 0xFF) se la matrice viene creata da un valore negativo BigInteger . Il bit non è impostato (il valore del byte è zero), se la matrice viene creata da un valore positivo 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

Nell'esempio seguente viene illustrato come assicurarsi che un valore positivo non venga creato erroneamente come valore negativo aggiungendo un byte il cui valore è zero alla fine della matrice.

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.

Commenti

I singoli byte nella value matrice devono essere in ordine little-endian, da byte di ordine più basso a byte di ordine più alto. Ad esempio, il valore numerico 1.000.000.000.000 è rappresentato come illustrato nella tabella seguente:


Stringa esadecimale	E8D4A51000
Matrice di byte (indice più basso per primo)	00 10 A5 D4 E8 00

La maggior parte dei metodi che converte valori numerici in matrici di byte, ad esempio BigInteger.ToByteArray e BitConverter.GetBytes, restituiscono matrici di byte in ordine little-endian.

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 di complemento di due. In altre parole, se viene impostato il bit di ordine più alto del byte di ordine più alto in value , il valore risultante BigInteger è negativo. A seconda dell'origine della matrice di byte, è possibile che un valore positivo venga interpretato erroneamente come valore negativo. Le matrici di byte vengono in genere generate nei modi seguenti:

Chiamando il BigInteger.ToByteArray metodo . Poiché questo metodo restituisce una matrice di byte con il bit di ordine più alto del byte di ordine più alto nella matrice impostata su zero per i valori positivi, non è possibile che venga interpretato erroneamente un valore positivo come negativo. Matrici di byte non modificate create dal ToByteArray metodo viene sempre eseguito correttamente il round trip quando vengono passate al BigInteger(Byte[]) costruttore.
Chiamando il BitConverter.GetBytes metodo e passando un intero con segno come parametro. Poiché gli interi con segno gestiscono sia la rappresentazione di segno che la rappresentazione di grandezza e la rappresentazione di complemento di due, non esiste alcuna possibilità di interpretazione errata di un valore positivo come negativo.
Chiamando il BitConverter.GetBytes metodo e passando un intero senza segno come parametro. Poiché gli interi senza segno sono rappresentati solo dalla loro grandezza, i valori positivi possono essere interpretati erroneamente come valori negativi. Per evitare questa interpretazione errata, è possibile aggiungere un valore di byte zero alla fine della matrice. L'esempio nella sezione successiva fornisce un'illustrazione.
Creando una matrice di byte in modo dinamico o statico senza necessariamente chiamare uno dei metodi precedenti o modificando una matrice di byte esistente. Per evitare che i valori positivi vengano interpretati erroneamente come valori negativi, è possibile aggiungere un valore di byte zero alla fine della matrice.

Se value è una matrice vuota Byte , il nuovo BigInteger oggetto viene inizializzato in un valore di BigInteger.Zero. Se value è null, il costruttore genera un'eccezione ArgumentNullException.

Vedi anche

ToByteArray()

Si applica a

BigInteger(Decimal)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore Decimal.

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.

Esempio

Nell'esempio seguente viene illustrato l'uso del costruttore per creare un'istanza di BigInteger(Decimal) un BigInteger oggetto . Definisce una matrice di Decimal valori e quindi passa ogni valore al BigInteger(Decimal) costruttore. Si noti che il Decimal valore viene troncato anziché arrotondato quando viene assegnato all'oggetto 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.

Commenti

Il risultato della chiamata a questo costruttore è identico all'assegnazione esplicita di un Decimal valore a una BigInteger variabile.

La chiamata a questo costruttore può causare la perdita di dati; qualsiasi parte frazionaria di viene troncata quando si crea un'istanza di value un BigInteger oggetto .

Si applica a

BigInteger(Double)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione doppia.

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 e precisione doppia.

Eccezioni

OverflowException

value è NaN, NegativeInfinity o PositiveInfinity.

Esempio

Nell'esempio seguente viene illustrato l'uso del costruttore per creare un'istanza di BigInteger(Double) un BigInteger oggetto . Illustra anche la perdita di precisione che può verificarsi quando si usa il Double tipo di dati. A Double un oggetto viene assegnato un valore di grandi dimensioni, che viene quindi assegnato a un BigInteger oggetto . Come illustrato nell'output, questa assegnazione comporta una perdita di precisione. Entrambi i valori vengono quindi incrementati di uno. L'output mostra che l'oggetto BigInteger riflette il valore modificato, mentre l'oggetto Double non lo fa.

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

Commenti

Qualsiasi parte frazionaria del value parametro viene troncata quando si crea un'istanza di un BigInteger oggetto .

A causa della mancanza di precisione del Double tipo di dati, la chiamata a questo costruttore può causare la perdita di dati.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione esplicita di un Double valore a un oggetto BigInteger.

Si applica a

BigInteger(Int32)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Inizializza una nuova istanza della struttura BigInteger utilizzando un Signed Integer a 32 bit.

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.

Esempio

Nell'esempio seguente viene chiamato il BigInteger(Int32) costruttore per creare BigInteger istanze di valori da una matrice di interi a 32 bit. Usa anche la conversione implicita per assegnare ogni valore intero a 32 bit a una BigInteger variabile. Confronta quindi i due valori per stabilire che i valori risultanti BigInteger sono uguali.

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

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un BigInteger oggetto usando questo costruttore.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un Int32 valore a un oggetto BigInteger.

La BigInteger struttura non include costruttori con un parametro di tipo Byte, , Int16 SByteo UInt16. Tuttavia, il Int32 tipo supporta la conversione implicita di interi con segno a 8 bit e a 16 bit e senza segno in interi con segno a 32 bit. Di conseguenza, questo costruttore viene chiamato se value è uno di questi quattro tipi integrali.

Si applica a

BigInteger(Int64)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Inizializza una nuova istanza della struttura BigInteger usando un valore intero con segno a 64 bit.

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.

Esempio

Nell'esempio seguente viene chiamato il BigInteger(Int64) costruttore per creare BigInteger istanze di valori da una matrice di interi a 64 bit. Usa anche la conversione implicita per assegnare ogni valore intero a 64 bit a una BigInteger variabile. Confronta quindi i due valori per stabilire che i valori risultanti BigInteger sono uguali.

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

Commenti

Non si verifica alcuna perdita di precisione quando si crea un'istanza di un BigInteger oggetto usando questo costruttore.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un Int64 valore a un oggetto BigInteger.

Si applica a

BigInteger(Single)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Inizializza una nuova istanza della struttura BigInteger utilizzando un valore a virgola mobile con precisione singola.

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 e precisione singola.

Eccezioni

OverflowException

value è NaN, NegativeInfinity o PositiveInfinity.

Esempio

Nell'esempio seguente viene illustrato l'uso del costruttore per creare un'istanza di BigInteger(Single) un BigInteger oggetto . Illustra anche la perdita di precisione che può verificarsi quando si usa il Single tipo di dati. A Single un oggetto viene assegnato un valore negativo di grandi dimensioni, che viene quindi assegnato a un BigInteger oggetto . Come illustrato nell'output, questa assegnazione comporta una perdita di precisione. Entrambi i valori vengono quindi incrementati di uno. L'output mostra che l'oggetto BigInteger riflette il valore modificato, mentre l'oggetto Single non lo fa.

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

Commenti

Qualsiasi parte frazionaria del value parametro viene troncata quando si crea un'istanza di un BigInteger oggetto .

A causa della mancanza di precisione del Single tipo di dati, la chiamata a questo costruttore può comportare una perdita di dati.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione esplicita di un Single valore a un oggetto BigInteger.

Si applica a

BigInteger(UInt32)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

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.

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)

Parametri

value: UInt32

Valore intero senza segno a 32 bit.

Attributi: CLSCompliantAttribute

Esempio

Nell'esempio seguente viene utilizzato il BigInteger(UInt32) costruttore e un'istruzione di assegnazione per inizializzare i BigInteger valori da una matrice di interi senza segno a 32 bit. Confronta quindi i due valori per dimostrare che i due metodi di inizializzazione di un BigInteger valore producono risultati identici.

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.

Commenti

Non si verifica alcuna perdita di precisione durante la creazione di un'istanza di utilizzando BigInteger questo costruttore.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un UInt32 valore a un oggetto BigInteger.

Si applica a

BigInteger(UInt64)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

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.

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)

Parametri

value: UInt64

Intero senza segno a 64 bit.

Attributi: CLSCompliantAttribute

Esempio

Nell'esempio seguente viene utilizzato il costruttore per creare un'istanza BigInteger(UInt64) di un BigInteger oggetto il cui valore è uguale a 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

Commenti

Non si verifica alcuna perdita di precisione durante la creazione di un'istanza di utilizzando BigInteger questo costruttore.

Il BigInteger valore risultante dalla chiamata a questo costruttore è identico al valore risultante dall'assegnazione di un UInt64 valore a un oggetto BigInteger.

Si applica a

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

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.

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.

isUnsigned: Boolean

true per indicare che value usa la codifica senza segno; in caso contrario, false (valore predefinito).

isBigEndian: Boolean

true per indicare value che è in ordine di byte big-endian; in caso contrario, false (valore predefinito).

Si applica a

Condividi tramite

BigInteger Costruttori

Definizione

Overload

BigInteger(Byte[])

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

BigInteger(Decimal)

Parametri

Esempio

Commenti

Si applica a

BigInteger(Double)

Parametri

Eccezioni

Esempio

Commenti

Si applica a

BigInteger(Int32)

Parametri

Esempio

Commenti

Si applica a

BigInteger(Int64)

Parametri

Esempio

Commenti

Si applica a

BigInteger(Single)

Parametri

Eccezioni

Esempio

Commenti

Si applica a

BigInteger(UInt32)

Parametri

Esempio

Commenti

Si applica a

BigInteger(UInt64)

Parametri

Esempio

Commenti

Si applica a

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Parametri

Si applica a

Risorse aggiuntive