BigInteger Структура

Определение

Представляет произвольно большое целое число со знаком.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
Наследование
BigInteger
Атрибуты
Реализации

Комментарии

Тип BigInteger — это неизменяемый тип, представляющий произвольно большое целое число, значение которого теоретически не имеет верхней или нижней границ.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Элементы типа BigInteger тесно параллельны с другими целочисленными типами (Byte, Int16, Int32, Int64, SByte, UInt16, UInt32и 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). Этот тип отличается от других целочисленных типов в .NET Framework.NET Framework, имеющих диапазон, определяемый их MinValue и 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.

Примечание

Так как тип BigInteger является неизменяемым (см. раздел изменяемость и структура BigInteger), а так как он не имеет верхней или нижней границы, для любой операции, которая вызывает слишком большое значение BigInteger, может быть вызвано OutOfMemoryException.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.

Создание экземпляра объекта BigIntegerInstantiating a BigInteger Object

Создать экземпляр объекта BigInteger можно несколькими способами.You can instantiate a BigInteger object in several ways:

  • Можно использовать ключевое слово new и предоставить любое целое число или значение с плавающей запятой в качестве параметра конструктору BigInteger.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Значения с плавающей запятой усекаются до того, как они будут назначены BigIntegerу.) В следующем примере показано, как использовать ключевое слово new для создания экземпляра BigInteger значений.(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		
    
  • Можно объявить переменную BigInteger и присвоить ей значение точно так же, как любой числовой тип, если это значение является целочисленным типом.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. В следующем примере оператор присваивания используется для создания BigInteger значения из 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
    
  • При приведении значения или первом преобразовании его можно присвоить значение типа Decimal или float с плавающей запятой объекту BigInteger.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. В следующем примере явным образом приводится ( C#в) или преобразуется (в Visual Basic)DoubleиDecimalзначение в 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      
    

Эти методы позволяют создать экземпляр объекта BigInteger, значение которого находится в диапазоне одного из существующих числовых типов.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Можно создать экземпляр объекта BigInteger, значение которого может превышать диапазон существующих числовых типов одним из трех способов:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Можно использовать ключевое слово new и указать массив байтов любого размера в конструкторе BigInteger.BigInteger.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Например: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).
    
  • Можно вызвать методы Parse или TryParse, чтобы преобразовать строковое представление числа в BigInteger.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Например: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
    
  • Можно вызвать метод static (Shared в Visual Basic) BigInteger, который выполняет некоторую операцию с числовым выражением и Возвращает вычисленный BigInteger результат.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. В следующем примере это делается путем кубинг UInt64.MaxValue и назначения результата 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
    

Неинициализированное значение BigIntegerZero.The uninitialized value of a BigInteger is Zero.

Выполнение операций с BigInteger значениямиPerforming Operations on BigInteger Values

Экземпляр BigInteger можно использовать так же, как любой другой целочисленный тип.You can use a BigInteger instance as you would use any other integral type. BigInteger перегружает стандартные числовые операторы, позволяя выполнять базовые математические операции, такие как сложение, вычитание, деление, умножение, вычитание, отрицание и унарное отрицание.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. Можно также использовать стандартные числовые операторы для сравнения двух значений BigInteger друг с другом.You can also use the standard numeric operators to compare two BigInteger values with each other. Как и другие целочисленные типы, BigInteger также поддерживает побитовые And, Or, XOr, сдвиг влево и операторы сдвига вправо.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Для языков, которые не поддерживают пользовательские операторы, структура BigInteger также предоставляет эквивалентные методы для выполнения математических операций.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. К ним относятся Add, Divide, Multiply, Negate, Subtractи несколько других.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Многие члены структуры BigInteger соответствуют элементам других целочисленных типов напрямую.Many members of the BigInteger structure correspond directly to members of the other integral types. Кроме того, BigInteger добавляет следующие элементы:In addition, BigInteger adds members such as the following:

  • Sign, который возвращает значение, указывающее знак BigIntegerого значения.Sign, which returns a value that indicates the sign of a BigInteger value.

  • Abs, возвращающее абсолютное значение BigInteger значения.Abs, which returns the absolute value of a BigInteger value.

  • DivRem, который возвращает как частную, так и оставшуюся часть операции деления.DivRem, which returns both the quotient and remainder of a division operation.

  • GreatestCommonDivisor, который возвращает наибольший общий делитель двух BigInteger значений.GreatestCommonDivisor, which returns the greatest common divisor of two BigInteger values.

Многие из этих дополнительных элементов соответствуют членам класса Math, который предоставляет функциональные возможности для работы с примитивными числовыми типами.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Изменяемость и структура BigIntegerMutability and the BigInteger Structure

В следующем примере создается экземпляр объекта BigInteger, а затем его значение увеличивается на единицу.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)

Хотя в этом примере возникает изменение значения существующего объекта, это не так.Although this example appears to modify the value of the existing object, this is not the case. BigInteger объекты являются неизменяемыми. Это означает, что на внутреннем языке среда CLR создает новый объект BigInteger и присваивает ему значение, которое больше его предыдущего значения.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. Затем этот новый объект возвращается вызывающему объекту.This new object is then returned to the caller.

Примечание

Другие числовые типы в .NET Framework также являются неизменяемыми.The other numeric types in the .NET Framework are also immutable. Однако, поскольку тип BigInteger не имеет верхней или нижней границы, его значения могут увеличиваться очень большими и повлиять на производительность.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Хотя этот процесс является прозрачным для вызывающего, он приводит к снижению производительности.Although this process is transparent to the caller, it does incur a performance penalty. В некоторых случаях, особенно если повторяющиеся операции выполняются в цикле на очень больших BigIntegerх значений, производительность может быть значительной.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Например, в следующем примере операция выполняется повторно до миллиона раз, а значение BigInteger увеличивается на единицу каждый раз, когда операция выполняется.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

В этом случае можно повысить производительность, выполняя все промежуточные назначения переменной Int32.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Конечное значение переменной может быть назначено объекту BigInteger при выходе из цикла.The final value of the variable can then be assigned to the BigInteger object when the loop exits. Ниже приведен пример.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

Работа с массивами байтов и шестнадцатеричными строкамиWorking with Byte Arrays and Hexadecimal Strings

При преобразовании BigInteger значений в массивы байтов или при преобразовании массивов байтов в BigInteger значения необходимо учитывать порядок байтов.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. Структура BigInteger требует, чтобы отдельные байты в массиве байтов отображались в порядке с прямым порядком байтов (то есть байты нижнего порядка в значении предшествуют байтам более высокого порядка).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). Можно округлить BigInteger значение, вызвав метод ToByteArray, а затем передав полученный массив байтов в конструктор BigInteger(Byte[]), как показано в следующем примере.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

Чтобы создать экземпляр BigInteger значения из массива байтов, представляющего значение какого-либо другого целочисленного типа, можно передать целочисленное значение в метод BitConverter.GetBytes, а затем передать полученный массив байтов в конструктор 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. В следующем примере создается экземпляр BigInteger значение из массива байтов, представляющего значение 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

Структура BigInteger предполагает, что отрицательные значения хранятся с помощью представления дополнения двух.The BigInteger structure assumes that negative values are stored by using two's complement representation. Поскольку структура BigInteger представляет числовое значение без фиксированной длины, конструктор BigInteger(Byte[]) всегда интерпретирует наиболее значимый бит последнего байта в массиве как бит знака.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. Чтобы конструктор BigInteger(Byte[]) не обменять представление отрицательного значения, дополняющего два, на знак и величину положительного значения, положительные значения, в которых наиболее значимый бит последнего байта в массиве байтов, будут Обычно параметр должен включать дополнительный байт, значение которого равно 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. Например, 0xC0 0xBD 0xF0 0xFF — это шестнадцатеричное представление с прямым порядком байтов 1 000 000 или 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. Поскольку наиболее значимый бит последнего байта в этом массиве равен ON, значение массива байтов интерпретируется конструктором BigInteger(Byte[]) как-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. Чтобы создать экземпляр BigInteger, значение которого положительно, это массив байтов, элементы которого 0xC0 0xBD 0xF0 0xFF 0x00, должны передаваться в конструктор.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. Это показано в следующем примере.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      

Байтовые массивы, созданные методом ToByteArray из положительных значений, включают этот дополнительный байт нулевого значения.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Таким образом, структура BigInteger может успешно выполнять циклические значения, назначив их в, а затем восстановив их из байтовых массивов, как показано в следующем примере.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

Однако может потребоваться добавить этот дополнительный байт нулевого значения к массивам байтов, динамически создаваемым разработчиком или возвращаемых методами, которые преобразуют целые числа без знака в байтовые массивы (например, BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)и 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)).

При синтаксическом анализе шестнадцатеричной строки методы BigInteger.Parse(String, NumberStyles) и BigInteger.Parse(String, NumberStyles, IFormatProvider) предполагают, что если наиболее значимый бит первого байта в строке задан, или если первая шестнадцатеричная цифра строки представляет четыре младших бита байтового значения, значение представлено с помощью представления дополнения двух.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. Например, "FF01" и "F01" представляют десятичное значение-255.For example, both "FF01" and "F01" represent the decimal value -255. Чтобы отличить положительные значения от отрицательных, положительные значения должны включать ноль в начале.To differentiate positive from negative values, positive values should include a leading zero. Соответствующие перегрузки метода ToString при передаче строки формата "X" добавляют в возвращаемую шестнадцатеричную строку в качестве положительных значений ноль в начале.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. Это позволяет выполнять циклическое BigInteger значений с помощью методов ToString и Parse, как показано в следующем примере.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.

Однако шестнадцатеричные строки, созданные путем вызова методов ToString других целочисленных типов или перегрузок метода ToString, которые содержат параметр toBase, не указывают знак значения или исходный тип данных, из которого шестнадцатеричное значение строка была производной.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. Для успешного создания экземпляра BigInteger значения из такой строки требуется дополнительная логика.Successfully instantiating a BigInteger value from such a string requires some additional logic. В следующем примере показана одна возможная реализация.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.

Конструкторы

BigInteger(Byte[])

Инициализирует новый экземпляр структуры BigInteger, используя значения в массиве типа byte.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

Инициализирует новый экземпляр структуры BigInteger, используя значение Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой двойной точности.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное знаковое целое число.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число со знаком.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Инициализирует новый экземпляр структуры BigInteger, используя значения в диапазоне байтов, доступном только для чтения, и при необходимости указывая кодировку подписи и порядок следования байтов.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)

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой одиночной точности.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное целое число без знака.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число без знака.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

Свойства

IsEven

Указывает, равно ли значение текущего объекта BigInteger четному числу.Indicates whether the value of the current BigInteger object is an even number.

IsOne

Указывает, равно ли значение текущего объекта BigInteger значению One.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo

Указывает, равно ли значение текущего объекта BigInteger степени двух.Indicates whether the value of the current BigInteger object is a power of two.

IsZero

Указывает, равно ли значение текущего объекта BigInteger значению Zero.Indicates whether the value of the current BigInteger object is Zero.

MinusOne

Получает значение, представляющее минус единицу (-1).Gets a value that represents the number negative one (-1).

One

Получает значение, представляющее единицу (1).Gets a value that represents the number one (1).

Sign

Получает число, указывающее знак (минус, плюс или нуль) текущего объекта BigInteger.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero

Получает значение, представляющее 0 (нуль).Gets a value that represents the number 0 (zero).

Методы

Abs(BigInteger)

Получает абсолютное значение объекта BigInteger.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger)

Складывает два значения BigInteger и возвращает результат.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger)

Сравнивает два значения BigInteger и возвращает целое значение, которое показывает, больше или меньше первое значение по сравнению со вторым или равно ему.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)

Сравнивает данный экземпляр с другим экземпляром BigInteger и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению указанного объекта.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)

Сравнивает данный экземпляр с 64-разрядным знаковым целым числом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению 64-битового знакового целого числа.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)

Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.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)

Сравнивает данный экземпляр с 64-разрядным целым числом без знака и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим или большим по сравнению со значением 64-битового целого числа без знака или равным ему.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)

Делит одно значение BigInteger на другое и возвращает результат.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger)

Делит одно значение BigInteger на другое, возвращает результат, а также возвращает остаток в виде параметра вывода.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(BigInteger)

Возвращает значение, определяющее равны ли текущий экземпляр и указанный объект BigInteger.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Int64)

Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число со знаком.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(Object)

Возвращает значение, определяющее, равны ли текущий экземпляр и указанный объект.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число без знака.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean)

Возвращает число байтов, которое будет выводиться ToByteArray(Boolean, Boolean) и 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()

Возвращает хэш-код для текущего объекта BigInteger.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger)

Находит наибольший общий делитель двух значений BigInteger.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger)

Возвращает натуральный логарифм (с основанием e) указанного числа.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double)

Возвращает логарифм указанного числа в системе счисления с указанным основанием.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger)

Возвращает логарифм с основанием 10 указанного числа.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger)

Возвращает наибольшее из двух значений BigInteger.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger)

Возвращает наименьшее из двух значений BigInteger.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger)

Выполняет модульное деление числа, возведенного в степень другого числа.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger)

Возвращает произведение двух значений BigInteger.Returns the product of two BigInteger values.

Negate(BigInteger)

Меняет знак указанного значения BigInteger.Negates a specified BigInteger value.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Преобразует представление числа, содержащегося в указанном диапазоне символов только для чтения в указанном стиле в его эквивалент 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)

Преобразует строковое представление числа в его эквивалент типа BigInteger.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, IFormatProvider)

Преобразует строковое представление числа в указанном формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(String, NumberStyles)

Преобразует строковое представление числа с указанным стилем в его эквивалент в формате BigInteger.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, NumberStyles, IFormatProvider)

Преобразует строковое представление числа в указанном стиле и формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32)

Возводит значение BigInteger в заданную степень.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger)

Выполняет целочисленное деление двух значений BigInteger и возвращает остаток.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger)

Вычитает одно значение BigInteger из другого и возвращает результат.Subtracts one BigInteger value from another and returns the result.

ToByteArray()

Преобразует значение BigInteger в массив байтов.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Возвращает значение этого BigInteger в виде массива байтов, используя наименьшее количество байтов.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Если значение равно нулю, возвращает массив из одного байта, элемент которого равен 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToString()

Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider)

Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление, используя указанные сведения об особенностях форматирования для данного языка и региональных параметров.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String)

Преобразует числовое значение текущего объекта BigInteger в эквивалентное строковое представление с использованием указанного формата.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider)

Преобразует значение текущего объекта BigInteger в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях формата для определенного языка и региональных параметров.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)

Форматирует этот экземпляр длинного целого числа в диапазон символов.Formats this big integer instance into a span of characters.

TryParse(ReadOnlySpan<Char>, BigInteger)

Пытается преобразовать представление числа, содержащегося в указанном диапазоне символов только для чтения, в его эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.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)

Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.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)

Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.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)

Предпринимает попытку преобразования числа в формате, который определяется заданным стилем и языком и региональными параметрами, в эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.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)

Копирует значение этого BigInteger в парные байты с прямым порядком, используя наименьшее количество байт.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Если значение равно нулю, возвращает один байт, элемент которого равен 0x00.If the value is zero, outputs one byte whose element is 0x00.

Операторы

Addition(BigInteger, BigInteger)

Складывает значения двух указанных объектов BigInteger.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger)

Выполняет битовую операцию And для двух значений BigInteger.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger)

Выполняет битовую операцию Or для двух значений BigInteger.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger)

Уменьшает значение BigInteger на 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger)

Делит указанное значение BigInteger на другое указанное значение BigInteger, используя целочисленное деление.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(BigInteger, BigInteger)

Возвращает значение, указывающее, равны ли значения двух объектов BigInteger.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, Int64)

Возвращает значение, указывающее, равны ли значение BigInteger и длинное знаковое целое число.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, UInt64)

Возвращает значение, указывающее, равны ли значение BigInteger и длинное целое число без знака.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(Int64, BigInteger)

Возвращает значение, указывающее, равны ли длинное знаковое целое число и значение BigInteger.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(UInt64, BigInteger)

Возвращает значение, указывающее, равны ли длинное целое число без знака и значение BigInteger.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger)

Выполняет битовую операцию исключающего Or (XOr) для двух значений BigInteger.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(BigInteger to Byte)

Определяет явное преобразование объекта BigInteger в байтовое значение без знака.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Определяет явное преобразование объекта BigInteger в значение Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Определяет явное преобразование объекта BigInteger в значение Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Определяет явное преобразование объекта BigInteger в значение 16-битового знакового целого числа.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа со знаком.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа со знаком.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Определяет явное преобразование объекта BigInteger в значение 8-битового числа со знаком.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single)

Определяет явное преобразование объекта BigInteger в значение числа с плавающей запятой одиночной точности.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Определяет явное преобразование объекта BigInteger в значение 16-битового целого числа без знака.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа без знака.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа без знака.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Double.The compliant alternative is Double.

Explicit(Decimal to BigInteger)

Определяет явное преобразование объекта Decimal в значение BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Определяет явное преобразование значения Double в значение BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Single to BigInteger)

Определяет явное преобразование значения Single в значение BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger больше другого значения типа BigInteger.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThan(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше значения 64-битового знакового целого числа.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, UInt64)

Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger)

Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число больше или равно значению BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(UInt64, BigInteger)

Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThanOrEqual(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger больше или равно другому значению типа BigInteger.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового знакового целого числа.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового целого числа без знака.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число больше или равно значению BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака больше или равно значению 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)

Определяет неявное преобразование значения типа byte без знака в значение BigInteger.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int16 to BigInteger)

Определяет неявное преобразование 16-битового знакового целого числа в значение BigInteger.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Int32 to BigInteger)

Определяет неявное преобразование 32-разрядного целого числа со знаком в значение BigInteger.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int64 to BigInteger)

Определяет неявное преобразование 64-разрядного целого числа со знаком в значение BigInteger.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Implicit(SByte to BigInteger)

Определяет неявное преобразование 8-битового знакового целого числа в значение BigInteger.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — BigInteger(Int32).The compliant alternative is BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Определяет неявное преобразование 16-битового целого числа без знака в значение BigInteger.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Implicit(Int32 to BigInteger).The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Определяет неявное преобразование 32-разрядного целого числа без знака в значение BigInteger.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Implicit(Int64 to BigInteger).The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Определяет неявное преобразование 64-разрядного целого числа без знака в значение BigInteger.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. Совместимая альтернатива — Double.The compliant alternative is Double.

Increment(BigInteger)

Увеличивает значение BigInteger на 1.Increments a BigInteger value by 1.

Inequality(BigInteger, BigInteger)

Возвращает значение, указывающее, имеют ли два объекта BigInteger различные значения.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное знаковое целое число не равны.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

Inequality(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное целое число без знака не равны.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число и значение BigInteger не равны.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака и значение BigInteger не равны.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

LeftShift(BigInteger, Int32)

Сдвигает значение BigInteger на указанное число битов влево.Shifts a BigInteger value a specified number of bits to the left.

LessThan(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше другого значения типа BigInteger.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового знакового целого числа.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового целого числа без знака.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(Int64, BigInteger)

Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число меньше значения BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше значения BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше или равно другому значению типа BigInteger.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному знаковому целому числу.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

LessThanOrEqual(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному целому числу без знака.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число меньше или равно значению BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше или равно значению BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

Modulus(BigInteger, BigInteger)

Возвращает остаток от деления двух заданных значений BigInteger.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger)

Умножает два заданных значения BigInteger.Multiplies two specified BigInteger values.

OnesComplement(BigInteger)

Возвращает результат битовой операции дополнения до единицы для значения BigInteger.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32)

Сдвигает значение BigInteger на указанное число битов вправо.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger)

Вычитает значение BigInteger из другого значения BigInteger.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger)

Меняет знак указанного значения BigInteger.Negates a specified BigInteger value.

UnaryPlus(BigInteger)

Возвращает значение операнда BigInteger.Returns the value of the BigInteger operand. (Знак операнда не изменяется.)(The sign of the operand is unchanged.)

Явные реализации интерфейса

IComparable.CompareTo(Object)

Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.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.

Применяется к