BigInteger BigInteger BigInteger BigInteger Struct

Definição

Representa um inteiro com sinal 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
Herança
BigIntegerBigIntegerBigIntegerBigInteger
Atributos
Implementações

Comentários

O BigInteger tipo é um tipo imutável que representa um inteiro arbitrariamente grande cujo valor, em teoria tem sem limites superiores ou inferiores.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Os membros de BigInteger tipo muito semelhantes dos outros tipos integrais (o Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, e UInt64 tipos).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Esse tipo é diferente de outros tipos integrais na .NET Framework.NET Framework, que tem um intervalo indicado por seus MinValue e MaxValue propriedades.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.

Observação

Porque o BigInteger tipo é imutável (consulte Mutabilidade e a estrutura de BigInteger) e porque não há limites superiores ou inferiores, tem um OutOfMemoryException pode ser gerada para qualquer operação que faz com que um BigInteger valor cresça demais grande.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.

Criando uma instância de um objeto BigIntegerInstantiating a BigInteger Object

Você pode instanciar um BigInteger objeto de várias maneiras:You can instantiate a BigInteger object in several ways:

  • Você pode usar o new palavra-chave e forneça qualquer valor integral ou de ponto flutuante como um parâmetro para o BigInteger construtor.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Valores de ponto flutuante são truncadas antes que eles forem atribuídos a BigInteger.) O exemplo a seguir ilustra como usar o new palavra-chave para criar uma instância BigInteger valores.(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		
    
  • Você pode declarar um BigInteger variável e atribuir um valor, assim como você faria com qualquer tipo numérico, desde que esse valor é um tipo integral.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. O exemplo a seguir usa a atribuição para criar uma BigInteger valor de um 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
    
  • Você pode atribuir um valor decimal ou de ponto flutuante para um BigInteger objeto se você converter o valor ou convertê-lo pela primeira vez.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. O exemplo a seguir converte a (em c#) ou converte (no Visual Basic) explicitamente uma Double e uma Decimal valor para um 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      
    

Esses métodos permitem que você criar uma instância de um BigInteger somente tipos de objeto cujo valor está no intervalo de um dos numérico existente.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Você pode instanciar um BigInteger objeto cujo valor pode exceder o intervalo dos tipos numéricos existentes em uma das três maneiras:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Você pode usar o new palavra-chave e forneça uma matriz de bytes de qualquer tamanho para o BigInteger.BigInteger construtor.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Por exemplo: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).
    
  • Você pode chamar o Parse ou TryParse métodos para converter a representação de cadeia de caracteres de um número para um BigInteger.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Por exemplo: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
    
  • Você pode chamar um static (Shared no Visual Basic) BigInteger método que executa alguma operação em uma expressão numérica e retorna um calculado BigInteger resultado.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. O exemplo a seguir faz isso por cubing UInt64.MaxValue e atribuir o resultado para um 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
    

O valor não inicializado de um BigInteger é Zero.The uninitialized value of a BigInteger is Zero.

Realizando operações em valores BigIntegerPerforming Operations on BigInteger Values

Você pode usar um BigInteger como você usaria qualquer outro tipo integral da instância.You can use a BigInteger instance as you would use any other integral type. BigInteger sobrecarrega os operadores numéricos padrão para que você possa executar operações matemáticas básicas, como adição, subtração, divisão, multiplicação, subtração, negação e negação unária.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. Você também pode usar os operadores numéricos padrão para comparar dois BigInteger valores entre si.You can also use the standard numeric operators to compare two BigInteger values with each other. Como os outros tipos integrais BigInteger também dá suporte à operação bit a bit And, Or, XOr, esquerda shift e operadores de deslocamento para a direita.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Para idiomas que não dão suporte a operadores personalizados, o BigInteger estrutura também fornece métodos equivalentes para executar operações matemáticas.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Eles incluem Add, Divide, Multiply, Negate, Subtracte muitas outras.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Número de membros do BigInteger estrutura correspondem diretamente aos membros de outros tipos integrais.Many members of the BigInteger structure correspond directly to members of the other integral types. Além disso, BigInteger adiciona membros, como o seguinte:In addition, BigInteger adds members such as the following:

Muitos desses membros adicionais correspondem aos membros do Math classe, que fornece a funcionalidade para trabalhar com os tipos numéricos primitivos.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Mutabilidade e a estrutura de BigIntegerMutability and the BigInteger Structure

O exemplo a seguir instancia um BigInteger de objeto e, em seguida, incrementa o valor em um.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)

Embora esse exemplo é exibido modificar o valor do objeto existente, isso não é o caso.Although this example appears to modify the value of the existing object, this is not the case. BigInteger objetos são imutáveis, o que significa que, internamente, o common language runtime, na verdade, cria um novo BigInteger de objeto e atribui um valor maior do que seu valor anterior.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. Esse novo objeto é retornado ao chamador.This new object is then returned to the caller.

Observação

Os tipos numéricos no .NET Framework também são imutáveis.The other numeric types in the .NET Framework are also immutable. No entanto, porque o BigInteger tipo tem sem limites superiores ou inferiores, seus valores podem ficar muito grandes e ter um impacto mensurável no desempenho.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Embora esse processo é transparente para o chamador, incorre em uma penalidade de desempenho.Although this process is transparent to the caller, it does incur a performance penalty. Em alguns casos, especialmente quando repetidas operações são executadas em um loop em grandes BigInteger valores, essa penalidade de desempenho pode ser significativa.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Por exemplo, no exemplo a seguir, uma operação é executada repetidamente até um milhão de vezes e um BigInteger valor é incrementado em um sempre que a operação seja bem-sucedida.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

Nesse caso, você pode melhorar o desempenho executando todas as atribuições de intermediárias para um Int32 variável.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. O valor final da variável, em seguida, pode ser atribuído para o BigInteger objeto quando o loop é encerrado.The final value of the variable can then be assigned to the BigInteger object when the loop exits. O exemplo a seguir fornece uma ilustração.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

Trabalhando com matrizes de bytes e cadeias de caracteres hexadecimaisWorking with Byte Arrays and Hexadecimal Strings

Se você converter BigInteger valores a matrizes de bytes, ou se você converter matrizes de bytes para BigInteger valores, você deve considerar a ordem de bytes.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. O BigInteger estrutura espera que os bytes individuais em uma matriz de bytes para aparecer em ordem little endian (ou seja, os bytes de ordem inferior do valor precedem os bytes de ordem mais alta).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). Você pode ir e voltar uma BigInteger valor chamando o ToByteArray método e, em seguida, passando o byte resultante de matriz para o BigInteger(Byte[]) construtor, como mostra o exemplo a seguir.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

Para criar uma instância de um BigInteger valor de uma matriz de bytes que representa um valor de outro tipo integral, você pode passar o valor integral para o BitConverter.GetBytes método e, em seguida, passe o byte resultante de matriz para o BigInteger(Byte[]) construtor.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. O exemplo a seguir instancia um BigInteger valor de uma matriz de bytes que representa um Int16 valor.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

O BigInteger estrutura pressupõe que os valores negativos são armazenados usando a representação de complemento de dois.The BigInteger structure assumes that negative values are stored by using two's complement representation. Porque o BigInteger estrutura representa um valor numérico com nenhum comprimento fixo, o BigInteger(Byte[]) construtor sempre interpreta o bit mais significativo do último byte na matriz como um bit de sinal.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. Para impedir que o BigInteger(Byte[]) construtor de confuso de dois complemento representação de um valor negativo com a representação de sinal e magnitude de um valor positivo, positivo valores em que a maioria dos bits significativa do último byte na matriz de bytes seria normalmente conjunto deve incluir um byte adicional, cujo valor é 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. Por exemplo, 0xC0 0xBD 0xF0 0xFF é a representação hexadecimal de little endian de-1,000,000 ou 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. Como o bit mais significativo do último byte nessa matriz está em, o valor da matriz de bytes poderia ser interpretado pelo BigInteger(Byte[]) construtor como-1,000,000.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. Para instanciar um BigInteger cujo valor é positivo, uma matriz de bytes cujos elementos são 0xC0 0xBD 0xF0 0xFF 0x00 deve ser passado para o construtor.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. O exemplo a seguir ilustra essa situação.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      

Matrizes de bytes criados pelo ToByteArray método dos valores positivos de incluir esse valor extra zero byte.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Portanto, o BigInteger estrutura pode valores de ida e volta com êxito, atribuí-los para e, em seguida, restaurá-los de matrizes de bytes, como mostra o exemplo a seguir.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

No entanto, talvez seja necessário adicionar esse byte adicional do valor de zero para matrizes de bytes que são criados dinamicamente pelo desenvolvedor ou que são retornados por métodos que convertem inteiros sem sinal em matrizes de bytes (como 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)).

Ao analisar uma cadeia de caracteres hexadecimal, o BigInteger.Parse(String, NumberStyles) e BigInteger.Parse(String, NumberStyles, IFormatProvider) métodos supõem que, se o bit mais significativo do primeiro byte na cadeia de caracteres é definido, ou se o primeiro dígito hexadecimal da cadeia de caracteres representa os quatro bits inferiores de um valor de byte, o valor é representado usando a representação de complemento de dois.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. Por exemplo, "FF01" e "F01" representam o valor decimal-255.For example, both "FF01" and "F01" represent the decimal value -255. Para diferenciar positivo de valores negativos, a valores positivos devem incluir um zero à esquerda.To differentiate positive from negative values, positive values should include a leading zero. As sobrecargas relevantes a ToString método, quando eles são passados a cadeia de caracteres de formato "X", adicione um zero à esquerda para a cadeia de caracteres hexadecimal retornado para valores positivos.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. Isso torna possível a ida e volta BigInteger valores usando o ToString e Parse métodos, como mostra o exemplo a seguir.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.

No entanto, as cadeias de caracteres hexadecimais é criado chamando o ToString métodos de outros tipos integrais ou as sobrecargas do ToString método que incluem um toBase parâmetro não indicam o sinal do valor ou o tipo de dados de origem do qual a cadeia de caracteres hexadecimal foi derivada.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. Criando uma instância com êxito um BigInteger valor de uma cadeia de caracteres requer alguma lógica adicional.Successfully instantiating a BigInteger value from such a string requires some additional logic. O exemplo a seguir fornece uma implementação possível.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.

Construtores

BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[])

Inicializa uma nova instância da estrutura BigInteger usando os valores de uma matriz de bytes.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal)

Inicializa uma nova instância da estrutura BigInteger usando um valor Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double) BigInteger(Double) BigInteger(Double) BigInteger(Double)

Inicializa uma nova instância de estrutura BigInteger usando um valor de ponto flutuante de precisão dupla.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32) BigInteger(Int32) BigInteger(Int32) BigInteger(Int32)

Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro com sinal de 32 bits.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64) BigInteger(Int64) BigInteger(Int64) BigInteger(Int64)

Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro com sinal de 64 bits.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single) BigInteger(Single) BigInteger(Single) BigInteger(Single)

Inicializa uma nova instância da estrutura BigInteger usando um valor de ponto flutuante de precisão simples.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32)

Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro de 32 bits sem sinal.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64)

Inicializa uma nova instância da estrutura BigInteger com um valor inteiro de 64 bits sem sinal.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Propriedades

IsEven IsEven IsEven IsEven

Indica se o valor do objeto BigInteger atual é um número par.Indicates whether the value of the current BigInteger object is an even number.

IsOne IsOne IsOne IsOne

Indica se o valor do objeto BigInteger atual é One.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo

Indica se o valor do objeto BigInteger atual é uma potência de dois.Indicates whether the value of the current BigInteger object is a power of two.

IsZero IsZero IsZero IsZero

Indica se o valor do objeto BigInteger atual é Zero.Indicates whether the value of the current BigInteger object is Zero.

MinusOne MinusOne MinusOne MinusOne

Obtém um valor que representa o número um negativo (-1).Gets a value that represents the number negative one (-1).

One One One One

Obtém um valor que representa o número um (1).Gets a value that represents the number one (1).

Sign Sign Sign Sign

Obtém um número que indica o sinal (negativo, positivo ou zero) do objeto BigInteger atual.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero Zero Zero Zero

Obtém um valor que representa o número 0 (zero).Gets a value that represents the number 0 (zero).

Métodos

Abs(BigInteger) Abs(BigInteger) Abs(BigInteger) Abs(BigInteger)

Obtém o valor absoluto de um objeto BigInteger.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger)

Adiciona dois valores de BigInteger e retorna o resultado.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger)

Compara dois valores BigInteger e retorna um inteiro que indica se o primeiro valor é menor que, igual a ou maior que o segundo valor.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(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compara esta instância a um objeto especificado e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.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) CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64)

Compara essa instância a um inteiro sem sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro sem sinal de 64 bits.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.

CompareTo(Int64) CompareTo(Int64) CompareTo(Int64) CompareTo(Int64)

Compara essa instância a um inteiro com sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro com sinal de 64 bits.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(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger)

Compara esta instância a um segundo BigInteger e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.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.

Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger)

Divide um valor BigInteger em outro e retorna o resultado.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger)

Divide um valor BigInteger por outro, retorna o resultado e retorna o restante em um parâmetro de saída.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(Int64) Equals(Int64) Equals(Int64) Equals(Int64)

Retorna um valor que indica se a instância atual e um inteiro com sinal de 64 bits têm o mesmo valor.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger) Equals(BigInteger) Equals(BigInteger) Equals(BigInteger)

Retorna um valor que indica se a instância atual e um objeto BigInteger especificado têm o mesmo valor.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retorna um valor que indica se a instância atual e um objeto especificado têm o mesmo valor.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64) Equals(UInt64) Equals(UInt64) Equals(UInt64)

Retorna um valor que indica se a instância atual e um inteiro sem sinal de 64 bits têm o mesmo valor.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retorna o código hash para o objeto BigInteger atual.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger)

Localiza o maior divisor comum de dois valores BigInteger.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger) Log(BigInteger) Log(BigInteger) Log(BigInteger)

Retorna o logaritmo natural (de base e) de um número especificado.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double)

Retorna o logaritmo de um número especificado em uma base especificada.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger) Log10(BigInteger) Log10(BigInteger) Log10(BigInteger)

Retorna o logaritmo de base 10 de um número especificado.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger)

Retorna o maior dos dois valores BigInteger.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger)

Retorna o menor de dois valores BigInteger.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger)

Executa a divisão de módulo em um número elevado à potência de outro número.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Retorna o produto de dois valores BigInteger.Returns the product of two BigInteger values.

Negate(BigInteger) Negate(BigInteger) Negate(BigInteger) Negate(BigInteger)

Nega um valor BigInteger especificado.Negates a specified BigInteger value.

Parse(String) Parse(String) Parse(String) Parse(String)

Converte a representação da cadeia de caracteres de um número no BigInteger equivalente.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu BigInteger equivalente.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico da cultura especificado em seu equivalente de BigInteger.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu BigInteger equivalente.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32)

Gera um valor BigInteger à potência de um valor especificado.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger)

Executa a divisão do inteiro em dois valores BigInteger e retorna o restante.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger)

Subtrai um valor BigInteger de outro e retorna o resultado.Subtracts one BigInteger value from another and returns the result.

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

Converte um valor de BigInteger em uma matriz de bytes.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)
ToString() ToString() ToString() ToString()

Converte o valor numérico do objeto BigInteger atual na representação da cadeia de caracteres equivalente.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Converte o valor numérico do objeto BigInteger atual em sua representação de cadeia de caracteres equivalente usando as informações especificadas de formatação específicas de cultura.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(String)

Converte o valor numérico do objeto BigInteger atual para sua representação de cadeia de caracteres equivalente usando o formato especificado.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

Converte o valor numérico do objeto BigInteger atual em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas de cultura.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) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger)
TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger)

Tenta converter a representação de cadeia de caracteres de seu equivalente de BigInteger e retorna um valor que indica se a conversão foi bem-sucedida.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Tenta converter a representação de cadeia de caracteres de um número em um estilo e formato específico à cultura especificados no equivalente BigInteger e retorna um valor que indica se a conversão foi bem-sucedida.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) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

Operadores

Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger)

Adiciona os valores dos dois objetos BigInteger especificados.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger)

Executa uma operação And bit a bit em dois valores BigInteger.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger)

Executa uma operação Or bit a bit em dois valores BigInteger.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger)

Diminui um valor BigInteger em 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger)

Divide um valor BigInteger especificado por outro valor BigInteger especificado usando a divisão de inteiros.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger)

Retorna um valor que indica se um valor inteiro longo com sinal e um valor BigInteger são iguais.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64)

Retorna um valor que indica se um valor BigInteger e um valor inteiro longo com sinal são iguais.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger)

Retorna um valor que indica se os valores de dois objetos BigInteger são iguais.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger e um valor inteiro longo sem sinal são iguais.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger)

Retorna um valor que indica se um valor inteiro longo sem sinal e um valor BigInteger são iguais.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger)

Executa uma operação exclusiva Or bit a bit (XOr) em dois valores BigInteger.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Define uma conversão explícita de um objeto Decimal em um valor BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Define uma conversão explícita de um valor Double para um valor BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

Define uma conversão explícita de um objeto BigInteger em um valor de byte sem sinal.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

Define uma conversão explícita de um objeto BigInteger em um valor Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

Define uma conversão explícita de um objeto BigInteger em um valor Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro com sinal de 16 bits.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 32 bits.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 64 bits.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

Define uma conversão explícita de um objeto BigInteger em um valor de 8 bits com sinal.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

Define uma conversão explícita de um objeto BigInteger em um valor de ponto flutuante de precisão simples.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 16 bits.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 32 bits.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 64 bits.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Double.The compliant alternative is Double.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Define uma conversão explícita de um valor Single para um valor BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger)

Retorna um valor que indica se um valor BigInteger é maior que um inteiro sem sinal de 64 bits.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger é maior que um inteiro sem sinal de 64 bits.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger)

Retorna um valor que indica se um inteiro com sinal de 64 bits é maior que um valor BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64)

Retorna um valor que indica se um BigInteger é maior que um valor inteiro com sinal de 64 bits.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger)

Retorna um valor que indica se um valor BigInteger é maior que outro valor BigInteger.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger)

Retorna um valor que indica se um inteiro com sinal de 64 bits é maior ou igual a um valor BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64)

Retorna um valor que indica se um valor de BigInteger é maior ou igual a um valor inteiro com sinal de 64 bits.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger)

Retorna um valor que indica se um valor BigInteger é maior ou igual a outro valor BigInteger.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger é maior ou igual a um valor inteiro sem sinal de 64 bits.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger)

Retorna um valor que indica se um inteiro sem sinal de 64 bits é maior ou igual a um valor BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 32 bits em um valor BigInteger.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Implicit(Int64 to BigInteger).The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 16 bits em um valor BigInteger.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Implicit(Int32 to BigInteger).The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 8 bits em um valor BigInteger.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é BigInteger(Int32).The compliant alternative is BigInteger(Int32).

Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 64 bits em um valor BigInteger.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Double.The compliant alternative is Double.

Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 32 bits em um valor BigInteger.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 16 bits em um valor BigInteger.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger)

Define uma conversão implícita de um byte sem sinal em um valor BigInteger.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 64 bits em um valor BigInteger.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Increment(BigInteger) Increment(BigInteger) Increment(BigInteger) Increment(BigInteger)

Incrementa um valor BigInteger em 1.Increments a BigInteger value by 1.

Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger)

Retorna um valor que indica se um inteiro sem sinal de 64 bits e um valor BigInteger não são iguais.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger)

Retorna um valor que indica se dois objetos BigInteger têm valores diferentes.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger e um inteiro sem sinal de 64 bits não são iguais.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger)

Retorna um valor que indica se um inteiro com sinal de 64 bits e um valor BigInteger não são iguais.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64)

Retorna um valor que indica se um valor BigInteger e um inteiro com sinal de 64 bits não são iguais.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32)

Desloca um valor BigInteger um número especificado de bits para a esquerda.Shifts a BigInteger value a specified number of bits to the left.

LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger)

Retorna um valor que indica se um inteiro com sinal de 64 bits é menor que um valor BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64)

Retorna um valor que indica se um valor BigInteger é menor que um inteiro com sinal de 64 bits.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger)

Retorna um valor que indica se um valor BigInteger é menor que outro valor BigInteger.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger é menor que um inteiro sem sinal de 64 bits.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger)

Retorna um valor que indica se um inteiro sem sinal de 64 bits é menor que um valor BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger)

Retorna um valor que indica se um inteiro sem sinal de 64 bits é menor ou igual a um valor BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger)

Retorna um valor que indica se um valor BigInteger é menor ou igual a outro valor BigInteger.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64)

Retorna um valor que indica se um valor BigInteger é menor ou igual a um inteiro sem sinal de 64 bits.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger)

Retorna um valor que indica se um inteiro com sinal de 64 bits é menor ou igual a um valor BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64)

Retorna um valor que indica se um valor BigInteger é menor ou igual a um inteiro com sinal de 64 bits.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger)

Retorna o resto que resulta da divisão com dois valores especificados BigInteger.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Multiplica dois valores BigInteger especificados.Multiplies two specified BigInteger values.

OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger)

Retorna o complemento bit a bit de um valor BigInteger.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32)

Desloca um valor BigInteger um número especificado de bits para a direita.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger)

Subtrai um valor BigInteger de outro valor BigInteger.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger)

Nega um valor BigInteger especificado.Negates a specified BigInteger value.

UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger)

Retorna o valor do operando BigInteger.Returns the value of the BigInteger operand. (O sinal do operando permanece inalterado).(The sign of the operand is unchanged.)

Implantações explícitas de interface

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

Aplica-se a