BigInteger Struct

Definizione

Rappresenta un intero con segno arbitrariamente grande.Represents an arbitrarily large signed integer.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Ereditarietà
BigInteger
Attributi
Implementazioni

Commenti

Il tipo di BigInteger è un tipo non modificabile che rappresenta un Integer arbitrariamente grande il cui valore in teoria non ha limiti superiori o inferiori.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. I membri del BigInteger tipo sono strettamente paralleli a quelli di altri tipi integrali (i tipi di Byte, Int16, Int32, Int64, SByte, UInt16, UInt32e UInt64).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Questo tipo è diverso dagli altri tipi integrali nell'.NET Framework.NET Framework, che hanno un intervallo indicato dalle proprietà MinValue e MaxValue.This type differs from the other integral types in the .NET Framework.NET Framework, which have a range indicated by their MinValue and MaxValue properties.

Nota

Poiché il tipo di BigInteger non è modificabile (vedere mutevolezza e la struttura BigInteger) e perché non dispone di limiti superiori o inferiori, è possibile generare un OutOfMemoryException per qualsiasi operazione che causa un aumento del valore di un BigInteger.Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

Creazione di un'istanza di un oggetto BigIntegerInstantiating a BigInteger Object

È possibile creare un'istanza di un oggetto BigInteger in diversi modi:You can instantiate a BigInteger object in several ways:

  • È possibile usare la parola chiave new e fornire qualsiasi valore a virgola mobile o integrale come parametro al costruttore di BigInteger.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. I valori a virgola mobile vengono troncati prima di essere assegnati al BigInteger. Nell'esempio seguente viene illustrato come utilizzare la parola chiave new per creare un'istanza di BigInteger valori.(Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952		
    
    Dim bigIntFromDouble As New BigInteger(179032.6541)
    Console.WriteLine(bigIntFromDouble)
    Dim bigIntFromInt64 As New BigInteger(934157136952)
    Console.WriteLine(bigIntFromInt64)
    ' The example displays the following output:
    '   179032
    '   934157136952		
    
  • È possibile dichiarare una variabile di BigInteger e assegnarle un valore Analogamente a qualsiasi tipo numerico, purché tale valore sia un tipo integrale.You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. Nell'esempio seguente viene utilizzata l'assegnazione per creare un valore BigInteger da un Int64.The following example uses assignment to create a BigInteger value from an Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • È possibile assegnare un valore decimale o a virgola mobile a un oggetto BigInteger se si esegue il cast del valore o lo si converte per primo.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. Nell'esempio seguente viene eseguito il cast esplicito C#(in) o viene convertito (in Visual Basic) unaDoublee un valoreDecimala una BigInteger.The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to a BigInteger.

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

Questi metodi consentono di creare un'istanza di un oggetto BigInteger il cui valore è compreso nell'intervallo di uno dei tipi numerici esistenti.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. È possibile creare un'istanza di un oggetto BigInteger il cui valore può superare l'intervallo dei tipi numerici esistenti in uno dei tre modi seguenti:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • È possibile usare la parola chiave new e fornire una matrice di byte di qualsiasi dimensione al costruttore di BigInteger.BigInteger.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Ad esempio:For example:

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);    
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • È possibile chiamare i metodi Parse o TryParse per convertire la rappresentazione di stringa di un numero in un BigInteger.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Ad esempio:For example:

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • È possibile chiamare una static (Shared in Visual Basic) BigInteger metodo che esegue un'operazione su un'espressione numerica e restituisce un risultato di BigInteger calcolato.You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. Nell'esempio seguente viene eseguita questa operazione cubi UInt64.MaxValue e assegnando il risultato a una BigInteger.The following example does this by cubing UInt64.MaxValue and assigning the result to a BigInteger.

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

Il valore non inizializzato di un BigInteger viene Zero.The uninitialized value of a BigInteger is Zero.

Esecuzione di operazioni sui valori BigIntegerPerforming Operations on BigInteger Values

È possibile utilizzare un'istanza di BigInteger come si utilizzerebbe qualsiasi altro tipo integrale.You can use a BigInteger instance as you would use any other integral type. BigInteger esegue l'overload degli operatori numerici standard per consentire l'esecuzione di operazioni matematiche di base, ad esempio addizione, sottrazione, divisione, moltiplicazione, sottrazione, negazione e negazione unaria.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. È anche possibile usare gli operatori numerici standard per confrontare due valori di BigInteger.You can also use the standard numeric operators to compare two BigInteger values with each other. Analogamente agli altri tipi integrali, BigInteger supporta anche gli operatori bit per bit And, Or, XOr, MAIUSC a sinistra e Right Shift.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Per i linguaggi che non supportano gli operatori personalizzati, la struttura BigInteger fornisce anche metodi equivalenti per l'esecuzione di operazioni matematiche.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Sono inclusi Add, Divide, Multiply, Negate, Subtracte molti altri.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Molti membri della struttura BigInteger corrispondono direttamente ai membri degli altri tipi integrali.Many members of the BigInteger structure correspond directly to members of the other integral types. Inoltre, BigInteger aggiunge membri come i seguenti:In addition, BigInteger adds members such as the following:

Molti di questi membri aggiuntivi corrispondono ai membri della classe Math, che fornisce la funzionalità per lavorare con i tipi numerici primitivi.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Mutevolity e la struttura BigIntegerMutability and the BigInteger Structure

Nell'esempio seguente viene creata un'istanza di un oggetto BigInteger, quindi il valore viene incrementato di uno.The following example instantiates a BigInteger object and then increments its value by one.

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

Sebbene in questo esempio venga modificato il valore dell'oggetto esistente, questo non è il caso.Although this example appears to modify the value of the existing object, this is not the case. BigInteger gli oggetti non sono modificabili, il che significa che internamente il Common Language Runtime crea effettivamente un nuovo oggetto BigInteger e lo assegna a un valore maggiore del valore precedente.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. Questo nuovo oggetto viene quindi restituito al chiamante.This new object is then returned to the caller.

Nota

Anche gli altri tipi numerici nell'.NET Framework non sono modificabili.The other numeric types in the .NET Framework are also immutable. Tuttavia, poiché il tipo BigInteger non dispone di limiti superiore o inferiore, i relativi valori possono aumentare notevolmente e avere un effetto misurabile sulle prestazioni.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Sebbene questo processo sia trasparente per il chiamante, comporta una riduzione delle prestazioni.Although this process is transparent to the caller, it does incur a performance penalty. In alcuni casi, soprattutto quando le operazioni ripetute vengono eseguite in un ciclo su valori di BigInteger di dimensioni molto grandi, la riduzione delle prestazioni può essere significativa.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Nell'esempio seguente, ad esempio, un'operazione viene eseguita ripetutamente fino a un milione di volte e un valore BigInteger viene incrementato di uno ogni volta che l'operazione ha esito positivo.For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

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

In tal caso, è possibile migliorare le prestazioni eseguendo tutte le assegnazioni intermedie a una variabile Int32.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Il valore finale della variabile può quindi essere assegnato all'oggetto BigInteger quando il ciclo viene chiuso.The final value of the variable can then be assigned to the BigInteger object when the loop exits. Nell'esempio seguente viene illustrato questo concetto.The following example provides an illustration.

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

Utilizzo di matrici di byte e stringhe esadecimaliWorking with Byte Arrays and Hexadecimal Strings

Se si convertono BigInteger valori in matrici di byte o se si convertono matrici di byte in valori BigInteger, è necessario considerare l'ordine dei byte.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. La struttura BigInteger prevede che i singoli byte in una matrice di byte siano visualizzati in ordine little-endian, ovvero i byte di ordine inferiore del valore precedono i byte di ordine superiore.The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). È possibile eseguire il round trip di un valore BigInteger chiamando il metodo ToByteArray e quindi passando la matrice di byte risultante al costruttore BigInteger(Byte[]), come illustrato nell'esempio riportato di seguito.You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

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

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

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

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

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

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

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

Per creare un'istanza di un valore BigInteger da una matrice di byte che rappresenta un valore di un altro tipo integrale, è possibile passare il valore integrale al metodo BitConverter.GetBytes, quindi passare la matrice di byte risultante al costruttore di BigInteger(Byte[]).To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. Nell'esempio seguente viene creata un'istanza di un valore BigInteger da una matrice di byte che rappresenta un valore Int16.The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

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

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

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

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

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

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

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

La struttura BigInteger presuppone che i valori negativi vengano archiviati usando la rappresentazione in complemento a due.The BigInteger structure assumes that negative values are stored by using two's complement representation. Poiché la struttura BigInteger rappresenta un valore numerico senza lunghezza fissa, il costruttore di BigInteger(Byte[]) interpreta sempre il bit più significativo dell'ultimo byte della matrice come un bit di segno.Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. Per impedire al costruttore BigInteger(Byte[]) di confondere la rappresentazione in complemento a due di un valore negativo con la rappresentazione di segno e grandezza di un valore positivo, valori positivi in cui il bit più significativo dell'ultimo byte della matrice di byte in genere è necessario impostare un byte aggiuntivo il cui valore è 0.To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. Ad esempio, 0xC0 0xBD 0xF0 0xFF è la rappresentazione esadecimale little-endian di-1 milione o 4.293.967.296.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Poiché il bit più significativo dell'ultimo byte in questa matrice è on, il valore della matrice di byte verrebbe interpretato dal Costruttore BigInteger(Byte[]) come-1 milione.Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. Per creare un'istanza di un BigInteger il cui valore è positivo, una matrice di byte i cui elementi sono 0xC0 0xBD 0xF0 0xFF 0x00 devono essere passati al costruttore.To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. Questa condizione è illustrata nell'esempio seguente.The following example illustrates this.

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

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

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

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

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

Le matrici di byte create dal metodo ToByteArray dai valori positivi includono questo byte aggiuntivo di valore zero.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Pertanto, la struttura di BigInteger può eseguire correttamente il round trip dei valori assegnando loro a e quindi ripristinando le matrici di byte, come illustrato nell'esempio riportato di seguito.Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

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

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

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

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

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

Tuttavia, potrebbe essere necessario aggiungere questo byte aggiuntivo a zero valore a matrici di byte create dinamicamente dallo sviluppatore o restituite da metodi che convertono interi senza segno in matrici di byte (ad esempio BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)e BitConverter.GetBytes(UInt64)).However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

Quando si analizza una stringa esadecimale, i metodi BigInteger.Parse(String, NumberStyles) e BigInteger.Parse(String, NumberStyles, IFormatProvider) presuppongono che se è impostato il bit più significativo del primo byte nella stringa o se la prima cifra esadecimale della stringa rappresenta i quattro bit più bassi di un valore byte , il valore viene rappresentato mediante la rappresentazione in complemento a due.When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. Ad esempio, "FF01" e "F01" rappresentano il valore decimale-255.For example, both "FF01" and "F01" represent the decimal value -255. Per distinguere i valori positivi da quelli negativi, i valori positivi devono includere uno zero iniziali.To differentiate positive from negative values, positive values should include a leading zero. Gli overload pertinenti del metodo ToString, quando viene passata la stringa di formato "X", aggiungono uno zero principale alla stringa esadecimale restituita per i valori positivi.The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. In questo modo è possibile eseguire il round trip dei valori BigInteger usando i metodi ToString e Parse, come illustrato nell'esempio seguente.This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

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

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

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

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

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

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

Tuttavia, le stringhe esadecimali create chiamando il ToString metodi degli altri tipi integrali o gli overload del metodo ToString che includono un parametro toBase non indicano il segno del valore o il tipo di dati di origine da cui l'esadecimale stringa derivata.However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. La creazione di un'istanza di un valore BigInteger da una stringa di questo tipo richiede una logica aggiuntiva.Successfully instantiating a BigInteger value from such a string requires some additional logic. Nell'esempio seguente viene fornita una possibile implementazione.The following example provides one possible implementation.

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

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

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

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

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

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

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

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

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

Costruttori

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

Proprietà

IsEven

Indica se il valore dell'oggetto BigInteger corrente è un numero pari.Indicates whether the value of the current BigInteger object is an even number.

IsOne

Indica se il valore dell'oggetto BigInteger corrente è One.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo

Indica se il valore dell'oggetto BigInteger corrente è una potenza di due.Indicates whether the value of the current BigInteger object is a power of two.

IsZero

Indica se il valore dell'oggetto BigInteger corrente è Zero.Indicates whether the value of the current BigInteger object is Zero.

MinusOne

Ottiene un valore che rappresenta il numero negativo uno (-1).Gets a value that represents the number negative one (-1).

One

Ottiene un valore che rappresenta il numero uno (1).Gets a value that represents the number one (1).

Sign

Ottiene un numero che indica il segno (negativo, positivo o zero) dell'oggetto BigInteger corrente.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero

Ottiene un valore che rappresenta il numero 0 (zero).Gets a value that represents the number 0 (zero).

Metodi

Abs(BigInteger)

Ottiene il valore assoluto di un oggetto BigInteger.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger)

Somma due valori BigInteger e restituisce il risultato.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger)

Confronta due valori BigInteger e restituisce un Integer che indica se il primo valore è minore, uguale o maggiore rispetto al secondo valore.Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.

CompareTo(BigInteger)

Confronta questa istanza con un secondo BigInteger e restituisce un Integer che indica se il valore di questa istanza è minore, uguale o maggiore rispetto al valore dell'oggetto specificato.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Int64)

Confronta questa istanza con un intero con segno a 64 bit e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'intero con segno a 64 bit.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore rispetto al valore dell'oggetto specificato.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64)

Confronta questa istanza con un intero senza segno a 64 bit e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'intero senza segno a 64 bit.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

Divide(BigInteger, BigInteger)

Divide un valore BigInteger per un altro e restituisce il risultato.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger)

Divide un valore BigInteger per un altro, restituisce il risultato e restituisce il resto in un parametro di output.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(BigInteger)

Restituisce un valore che indica se l'istanza corrente e un oggetto BigInteger specificato hanno lo stesso valore.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Int64)

Restituisce un valore che indica se l'istanza corrente e un intero con segno a 64 bit hanno lo stesso valore.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(Object)

Restituisce un valore che indica se l'istanza corrente e un oggetto specificato hanno lo stesso valore.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Restituisce un valore che indica se l'istanza corrente e un intero senza segno a 64 bit hanno lo stesso valore.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean)

Ottiene il numero di byte che saranno restituiti da ToByteArray(Boolean, Boolean) e TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).Gets the number of bytes that will be output by ToByteArray(Boolean, Boolean) and TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).

GetHashCode()

Restituisce il codice hash per l'oggetto BigInteger corrente.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger)

Trova il massimo comune divisore di due valori BigInteger.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger)

Restituisce il logaritmo naturale (in base e) di un numero specificato.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double)

Restituisce il logaritmo del numero specificato in una base specificata.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger)

Restituisce il logaritmo in base 10 del numero specificato.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger)

Restituisce il maggiore di due valori BigInteger.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger)

Restituisce il minore di due valori BigInteger.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger)

Esegue la divisione con modulo per un numero elevato alla potenza di un altro numero.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger)

Restituisce il prodotto di due valori BigInteger.Returns the product of two BigInteger values.

Negate(BigInteger)

Nega un valore BigInteger specificato.Negates a specified BigInteger value.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte la rappresentazione di un numero, contenuto nell'intervallo di caratteri di sola lettura specificato, in uno stile specificato nell'equivalente BigInteger.Converts the representation of a number, contained in the specified read-only span of characters, in a specified style to its BigInteger equivalent.

Parse(String)

Converte la rappresentazione di stringa di un numero nell'oggetto BigInteger equivalente.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, IFormatProvider)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura indicato nell'oggetto BigInteger equivalente.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'oggetto BigInteger equivalente.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile specificato e un formato specifico delle impostazioni cultura indicato nell'oggetto BigInteger equivalente.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32)

Eleva alla potenza di un valore specificato il valore BigInteger.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger)

Esegue una divisione intera su due valori BigInteger e restituisce il resto.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger)

Sottrae un valore BigInteger da un altro e restituisce il risultato.Subtracts one BigInteger value from another and returns the result.

ToByteArray()

Converte un valore BigInteger in una matrice di byte.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Restituisce il valore di BigInteger come matrice di byte usando il minor numero possibile di byte.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Se il valore è zero, restituisce una matrice di un byte il cui elemento è 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToString()

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando le informazioni di formattazione specifiche delle impostazioni cultura indicate.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente, usando il formato specificato.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura indicate.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.

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

Formatta questa istanza di big integer in un intervallo di caratteri.Formats this big integer instance into a span of characters.

TryParse(ReadOnlySpan<Char>, BigInteger)

Prova a convertire la rappresentazione di un numero contenuto nell'intervallo di caratteri di sola lettura specificato nell'oggetto BigInteger equivalente e restituisce un valore che indica se la conversione è stata eseguita correttamente.Tries to convert the representation of a number contained in the specified read-only character span, to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Prova a convertire la rappresentazione di stringa di un numero nell'oggetto BigInteger equivalente e restituisce un valore che indica se la conversione è stata eseguita correttamente.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(String, BigInteger)

Prova a convertire la rappresentazione di stringa di un numero nell'oggetto BigInteger equivalente e restituisce un valore che indica se la conversione è stata eseguita correttamente.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Prova a convertire la rappresentazione di stringa di un numero in uno stile specificato e un formato specifico delle impostazioni cultura indicato nell'oggetto BigInteger equivalente e restituisce un valore che indica se la conversione è stata eseguita correttamente.Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Copia il valore di BigInteger come byte di complemento a due little endian usando il minor numero possibile di byte.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Se il valore è zero, restituisce un byte il cui elemento è 0x00.If the value is zero, outputs one byte whose element is 0x00.

Operatori

Addition(BigInteger, BigInteger)

Somma i valori di due oggetti BigInteger specificati.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger)

Esegue un'operazione And bit per bit su due valori BigInteger.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger)

Esegue un'operazione Or bit per bit su due valori BigInteger.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger)

Decrementa un valore BigInteger di 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger)

Divide un valore BigInteger specificato per un altro valore BigInteger specificato tramite una divisione intera.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(BigInteger, BigInteger)

Restituisce un valore che indica se i valori di due oggetti BigInteger sono uguali.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, Int64)

Restituisce un valore che indica se un valore Signed Long Integer e un valore BigInteger sono uguali.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, UInt64)

Restituisce un valore che indica se un valore Unsigned Long Integer e un valore BigInteger sono uguali.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(Int64, BigInteger)

Restituisce un valore che indica se un valore Signed Long Integer e un valore BigInteger sono uguali.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(UInt64, BigInteger)

Restituisce un valore che indica se un valore Unsigned Long Integer e un valore BigInteger sono uguali.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger)

Esegue un'operazione Or (XOr) bit per bit esclusiva su due valori BigInteger.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(BigInteger to Byte)

Definisce una conversione esplicita di un oggetto BigInteger in un valore byte senza segno.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Definisce una conversione esplicita di un oggetto BigInteger in un valore Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Definisce una conversione esplicita di un oggetto BigInteger in un valore Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Definisce una conversione esplicita di un oggetto BigInteger in un valore Signed Integer a 16 bit.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Definisce una conversione esplicita di un oggetto BigInteger in un valore intero con segno a 32 bit.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Definisce una conversione esplicita di un oggetto BigInteger in un valore intero con segno a 64 bit.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Definisce una conversione esplicita di un oggetto BigInteger in un valore a 8 bit con segno.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single)

Definisce una conversione esplicita di un oggetto BigInteger in un valore in virgola mobile a precisione singola.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Definisce una conversione esplicita di un oggetto BigInteger in un valore Unsigned Integer a 16 bit.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Definisce una conversione esplicita di un oggetto BigInteger in un valore intero senza segno a 32 bit.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Definisce una conversione esplicita di un oggetto BigInteger in un valore intero senza segno a 64 bit.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Double.The compliant alternative is Double.

Explicit(Decimal to BigInteger)

Definisce una conversione esplicita di un oggetto Decimal in un valore BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Definisce una conversione esplicita di un valore Double in un valore BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Single to BigInteger)

Definisce una conversione esplicita di un valore Single in un valore BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(BigInteger, BigInteger)

Restituisce un valore che indica se un valore BigInteger è maggiore di un altro valore BigInteger.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThan(BigInteger, Int64)

Restituisce un valore che indica se un BigInteger è maggiore di un valore Signed Integer a 64 bit.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, UInt64)

Restituisce un valore che indica se un valore BigInteger è maggiore di un Unsigned Integer a 64 bit.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger)

Restituisce un valore che indica se un Signed Integer a 64 bit è maggiore di un valore BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(UInt64, BigInteger)

Restituisce un valore che indica se un valore BigInteger è maggiore di un Unsigned Integer a 64 bit.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThanOrEqual(BigInteger, BigInteger)

Restituisce un valore che indica se un valore BigInteger è maggiore o uguale a un altro valore BigInteger.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, Int64)

Restituisce un valore che indica se un valore BigInteger è maggiore o uguale a un valore Signed Integer a 64 bit.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, UInt64)

Restituisce un valore che indica se un valore BigInteger è maggiore o uguale a un valore Unsigned Integer a 64 bit.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(Int64, BigInteger)

Restituisce un valore che indica se un Signed Integer a 64 bit è maggiore o uguale a un valore BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(UInt64, BigInteger)

Restituisce un valore che indica se un Unsigned Integer a 64 bit è maggiore o uguale a un valore BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(Byte to BigInteger)

Definisce una conversione implicita di un byte senza segno in un valore BigInteger.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int16 to BigInteger)

Definisce una conversione implicita di un Signed Integer a 16 bit in un valore BigInteger.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Int32 to BigInteger)

Definisce una conversione implicita di un intero con segno a 32 bit in un valore BigInteger.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int64 to BigInteger)

Definisce una conversione implicita di un intero con segno a 64 bit in un valore BigInteger.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Implicit(SByte to BigInteger)

Definisce una conversione implicita di un Signed Integer a 8 bit in un valore BigInteger.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è BigInteger(Int32).The compliant alternative is BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Definisce una conversione implicita di un Unsigned Integer a 16 bit in un valore BigInteger.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Implicit(Int32 to BigInteger).The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Definisce una conversione implicita di un intero senza segno a 32 bit in un valore BigInteger.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Implicit(Int64 to BigInteger).The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Definisce una conversione implicita di un intero senza segno a 64 bit in un valore BigInteger.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Questa API non è conforme a CLS.This API is not CLS-compliant. L'alternativa conforme è Double.The compliant alternative is Double.

Increment(BigInteger)

Incrementa un valore BigInteger di 1.Increments a BigInteger value by 1.

Inequality(BigInteger, BigInteger)

Restituisce un valore che indica se due oggetti BigInteger hanno valori diversi.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, Int64)

Restituisce un valore che indica se un valore BigInteger e un Signed Integer a 64 bit non sono uguali.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

Inequality(BigInteger, UInt64)

Restituisce un valore che indica se un valore BigInteger e un Unsigned Integer a 64 bit non sono uguali.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger)

Restituisce un valore che indica se un Signed Integer a 64 bit e un valore BigInteger non sono uguali.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(UInt64, BigInteger)

Restituisce un valore che indica se un Unsigned Integer a 64 bit e un valore BigInteger non sono uguali.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

LeftShift(BigInteger, Int32)

Sposta un valore BigInteger di un numero specificato di bit verso sinistra.Shifts a BigInteger value a specified number of bits to the left.

LessThan(BigInteger, BigInteger)

Restituisce un valore che indica se un valore BigInteger è minore di un altro valore BigInteger.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, Int64)

Restituisce un valore che indica se un valore BigInteger è minore di un Signed Integer a 64 bit.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, UInt64)

Restituisce un valore che indica se un valore BigInteger è minore di un Unsigned Integer a 64 bit.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(Int64, BigInteger)

Restituisce un valore che indica se un Signed Integer a 64 bit è minore di un valore BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(UInt64, BigInteger)

Restituisce un valore che indica se un Unsigned Integer a 64 bit è minore di un valore BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger)

Restituisce un valore che indica se un valore BigInteger è minore o uguale a un altro valore BigInteger.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, Int64)

Restituisce un valore che indica se un valore BigInteger è minore o uguale a un Signed Integer a 64 bit.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

LessThanOrEqual(BigInteger, UInt64)

Restituisce un valore che indica se un valore BigInteger è minore o uguale a un Unsigned Integer a 64 bit.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger)

Restituisce un valore che indica se un Signed Integer a 64 bit è minore o uguale a un valore BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(UInt64, BigInteger)

Restituisce un valore che indica se un Unsigned Integer a 64 bit è minore o uguale a un valore BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

Modulus(BigInteger, BigInteger)

Restituisce il resto risultante dalla divisione di due valori BigInteger specificati.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger)

Moltiplica due valori BigInteger specificati.Multiplies two specified BigInteger values.

OnesComplement(BigInteger)

Restituisce il complemento a uno bit per bit di un valore BigInteger.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32)

Sposta un valore BigInteger di un numero specificato di bit verso destra.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger)

Sottrae un valore BigInteger da un altro valore BigInteger.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger)

Nega un valore BigInteger specificato.Negates a specified BigInteger value.

UnaryPlus(BigInteger)

Restituisce il valore dell'operando BigInteger.Returns the value of the BigInteger operand. Il segno dell'operando resta invariato.(The sign of the operand is unchanged.)

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore rispetto al valore dell'oggetto specificato.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

Si applica a