BigInteger Структура

Ссылка

Определение

Пространство имен:: System.Numerics

Сборка:: System.Runtime.Numerics.dll

Сборка:: System.Numerics.dll

Сборка:: netstandard.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Представляет произвольно большое целое число со знаком.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable

public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, System::Numerics::IAdditionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IAdditiveIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IBinaryInteger<System::Numerics::BigInteger>, System::Numerics::IBinaryNumber<System::Numerics::BigInteger>, System::Numerics::IBitwiseOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IComparisonOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IDecrementOperators<System::Numerics::BigInteger>, System::Numerics::IDivisionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IEqualityOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IIncrementOperators<System::Numerics::BigInteger>, System::Numerics::IModulusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplicativeIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplyOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::INumber<System::Numerics::BigInteger>, System::Numerics::INumberBase<System::Numerics::BigInteger>, System::Numerics::IShiftOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::ISignedNumber<System::Numerics::BigInteger>, System::Numerics::ISubtractionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryNegationOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryPlusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>

public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable

public readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, System.Numerics.IAdditionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IBinaryInteger<System.Numerics.BigInteger>, System.Numerics.IBinaryNumber<System.Numerics.BigInteger>, System.Numerics.IBitwiseOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IComparisonOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IDecrementOperators<System.Numerics.BigInteger>, System.Numerics.IDivisionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IEqualityOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IIncrementOperators<System.Numerics.BigInteger>, System.Numerics.IModulusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplyOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.INumber<System.Numerics.BigInteger>, System.Numerics.INumberBase<System.Numerics.BigInteger>, System.Numerics.IShiftOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.ISignedNumber<System.Numerics.BigInteger>, System.Numerics.ISubtractionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryNegationOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryPlusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>

[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

type BigInteger = struct
    interface IFormattable

type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable

type BigInteger = struct
    interface IFormattable
    interface IParsable<BigInteger>
    interface ISpanFormattable
    interface ISpanParsable<BigInteger>
    interface IAdditionOperators<BigInteger, BigInteger, BigInteger>
    interface IAdditiveIdentity<BigInteger, BigInteger>
    interface IBinaryInteger<BigInteger>
    interface IBinaryNumber<BigInteger>
    interface IBitwiseOperators<BigInteger, BigInteger, BigInteger>
    interface IComparisonOperators<BigInteger, BigInteger>
    interface IEqualityOperators<BigInteger, BigInteger>
    interface IDecrementOperators<BigInteger>
    interface IDivisionOperators<BigInteger, BigInteger, BigInteger>
    interface IIncrementOperators<BigInteger>
    interface IModulusOperators<BigInteger, BigInteger, BigInteger>
    interface IMultiplicativeIdentity<BigInteger, BigInteger>
    interface IMultiplyOperators<BigInteger, BigInteger, BigInteger>
    interface INumber<BigInteger>
    interface INumberBase<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IShiftOperators<BigInteger, BigInteger>
    interface ISignedNumber<BigInteger>

[<System.Serializable>]
type BigInteger = struct
    interface IFormattable

Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable

Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable

Public Structure BigInteger
Implements IAdditionOperators(Of BigInteger, BigInteger, BigInteger), IAdditiveIdentity(Of BigInteger, BigInteger), IBinaryInteger(Of BigInteger), IBinaryNumber(Of BigInteger), IBitwiseOperators(Of BigInteger, BigInteger, BigInteger), IComparable(Of BigInteger), IComparisonOperators(Of BigInteger, BigInteger), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger), IEquatable(Of BigInteger), IIncrementOperators(Of BigInteger), IModulusOperators(Of BigInteger, BigInteger, BigInteger), IMultiplicativeIdentity(Of BigInteger, BigInteger), IMultiplyOperators(Of BigInteger, BigInteger, BigInteger), INumber(Of BigInteger), INumberBase(Of BigInteger), IParsable(Of BigInteger), IShiftOperators(Of BigInteger, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger)

Наследование: Object

ValueType
BigInteger

Атрибуты: SerializableAttribute

Реализации: IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanParsable<BigInteger> ISpanParsable<TSelf> IAdditionOperators<BigInteger,BigInteger,BigInteger> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<BigInteger,BigInteger> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<BigInteger> IBinaryNumber<BigInteger> IBinaryNumber<TSelf> IBitwiseOperators<BigInteger,BigInteger,BigInteger> IBitwiseOperators<TSelf,TSelf,TSelf> System.Numerics.IComparisonOperators<BigInteger,BigInteger> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<BigInteger,BigInteger> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> IIncrementOperators<BigInteger> IIncrementOperators<TSelf> IModulusOperators<BigInteger,BigInteger,BigInteger> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<BigInteger,BigInteger> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<BigInteger,BigInteger,BigInteger> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<BigInteger> INumber<TSelf> INumberBase<BigInteger> INumberBase<TSelf> System.Numerics.IShiftOperators<BigInteger,BigInteger> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf>

Тип BigInteger — это неизменяемый тип, представляющий произвольно большое целое число, значение которого в теории не имеет верхних или нижних границ. Члены BigInteger типа тесно параллельны другим целочисленным типам (, Byte, Int16, Int32 Int64, SByte, UInt16 UInt32и UInt64 типы). Этот тип отличается от других целочисленных типов в платформа .NET Framework, которые имеют диапазон, указанный их MinValue свойствами и MaxValue свойствами.

Примечание

BigInteger Поскольку тип является неизменяемым (см. мутируемость и структура BigInteger) и поскольку он не имеет верхних или нижних границ, можно создать исключение для любой операции, OutOfMemoryException которая приводит BigInteger к слишком большому значению.

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

Создать экземпляр BigInteger объекта можно несколькими способами:

Ключевое new слово можно использовать и указать любое целочисленное или плавающее значение в качестве параметра конструктору BigInteger . (Значения с плавающей запятой усекаются перед назначением . BigInteger) В следующем примере показано, как использовать ключевое new слово для создания BigInteger экземпляров значений.
```
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 и назначить ей значение так же, как и любой числовой тип, если это значение является целочисленным типом. В следующем примере используется назначение для создания BigInteger значения из .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
```

Десятичное или плавающее значение можно назначить объекту BigInteger , если сначала привести значение или преобразовать его. В следующем примере явно выполняется приведение (в C#) или преобразование (в Visual Basic) Double и Decimal значение в .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 экземпляр объекта, значение которого находится только в диапазоне одного из существующих числовых типов. Можно создать BigInteger экземпляр объекта, значение которого может превышать диапазон существующих числовых типов одним из трех способов:

Ключевое new слово можно использовать и предоставить массив байтов любого размера конструктору BigInteger.BigInteger . Пример:

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 Пример:

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 результат. В следующем примере это делается путем кубинга UInt64.MaxValue и назначения результата объекту 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
```

Неинициализированное значение аBigInteger.Zero

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

Экземпляр можно использовать BigInteger так же, как и любой другой целочисленный тип. BigInteger перегружает стандартные числовые операторы, позволяющие выполнять основные математические операции, такие как сложение, вычитание, деление, умножение и унарное отрицание. Можно также использовать стандартные числовые операторы для сравнения двух BigInteger значений друг с другом. Как и другие целочисленные типы, BigInteger также поддерживает побитовые Andоператоры , , Or``XOrсдвиг влево и вправо. Для языков, которые не поддерживают пользовательские операторы, BigInteger структура также предоставляет эквивалентные методы для выполнения математических операций. К ним относятсяAdd, , Divide, Multiply, Negate Subtractи несколько других.

Многие члены BigInteger структуры соответствуют непосредственно членам других целочисленных типов. Кроме того, добавляет такие элементы, BigInteger как:

Sign, который возвращает значение, указывающее знак BigInteger значения.
Abs, который возвращает абсолютное значение BigInteger значения.
DivRem, который возвращает как цитиент, так и оставшуюся часть операции деления.
GreatestCommonDivisor, который возвращает наибольший общий делитель двух BigInteger значений.

Многие из этих дополнительных элементов соответствуют членам Math класса, которые предоставляют функциональные возможности для работы с примитивами числовыми типами.

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

В следующем примере создается экземпляр BigInteger объекта, а затем увеличивается его значение на один.

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)

Хотя этот пример, как представляется, изменяет значение существующего объекта, это не так. BigInteger объекты являются неизменяемыми, что означает, что среда CLR фактически создает новый BigInteger объект и присваивает ему значение больше, чем предыдущее значение. Затем этот новый объект возвращается вызывающей объекту.

Примечание

Другие числовые типы в .NET также неизменяемы. Тем не менее, поскольку BigInteger тип не имеет верхних или нижних границ, его значения могут увеличиваться очень большими и оказывать значительное влияние на производительность.

Хотя этот процесс является прозрачным для вызывающего объекта, он приводит к штрафу производительности. В некоторых случаях, особенно если повторяющиеся операции выполняются в цикле с очень большими BigInteger значениями, производительность может быть значительной. Например, в следующем примере операция выполняется повторно до миллиона раз, а BigInteger значение увеличивается по одному при каждом успешном выполнении операции.

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 . Окончательное значение переменной можно присвоить объекту BigInteger при выходе цикла. Ниже приведен пример.

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

Работа с массивами байтов и шестнадцатеричными строками

При преобразовании BigInteger значений в массивы байтов или при преобразовании массивов байтов в BigInteger значения необходимо учитывать порядок байтов. Структура BigInteger ожидает, что отдельные байты в массиве байтов будут отображаться в байтовом порядке (т. е. байты нижнего порядка значения перед байтами более высокого порядка). Можно обойти BigInteger значение, вызвав ToByteArray метод, а затем передав результирующий массив байтов конструктору BigInteger(Byte[]) , как показано в следующем примере.

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

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 структуре предполагается, что отрицательные значения хранятся с помощью представления дополнения двух. BigInteger Поскольку структура представляет числовое значение без фиксированной длины, BigInteger(Byte[]) конструктор всегда интерпретирует наиболее значимый бит последнего байта в массиве в виде бита знака. Чтобы конструктор не BigInteger(Byte[]) запутал представление отрицательного значения со знаком и величиной положительного значения, положительные значения, в которых наиболее значимый бит последнего байта в массиве байтов обычно должен содержать дополнительный байт, значение которого равно 0. Например, 0xC0 0xBD 0xF0 0xFF является шестнадцатеричным представлением -1 000 000 или 4 293 967 2966. Так как самый значительный бит последнего байта в этом массиве включен, значение массива байтов будет интерпретироваться конструктором BigInteger(Byte[]) как -1000 000. Чтобы создать экземпляр положительного BigInteger значения, массив байтов, элементы которого 0xC0 0xBD 0xF0 0xFF 0x00 должны передаваться конструктору. Это показано в следующем примере.

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

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

При синтаксическом анализе шестнадцатеричной строки BigInteger.Parse(String, NumberStyles) и BigInteger.Parse(String, NumberStyles, IFormatProvider) методы предполагают, что если задан самый значительный бит первого байта в строке, или если первая шестнадцатеричная цифра строки представляет нижние четыре бита байтового значения, значение представляется с помощью представления дополнения двух значений. Например, как "FF01", так и "F01" представляют десятичное значение -255. Чтобы отличить положительные от отрицательных значений, положительные значения должны включать начальный ноль. Соответствующие перегрузки ToString метода, когда они передают строку формата "X", добавьте начальный ноль в возвращенную шестнадцатеричную строку для положительных значений. Это позволяет использовать значения кругового пути BigInteger с помощью ToString методов и Parse методов, как показано в следующем примере.

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

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.
BigInteger(Decimal)	Инициализирует новый экземпляр структуры BigInteger, используя значение Decimal.
BigInteger(Double)	Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой двойной точности.
BigInteger(Int32)	Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное знаковое целое число.
BigInteger(Int64)	Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число со знаком.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Инициализирует новый экземпляр структуры BigInteger, используя значения в диапазоне байтов, доступном только для чтения, и при необходимости указывая кодировку подписи и порядок следования байтов.
BigInteger(Single)	Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой одиночной точности.
BigInteger(UInt32)	Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное целое число без знака.
BigInteger(UInt64)	Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число без знака.

Свойства

IsEven	Указывает, равно ли значение текущего объекта BigInteger четному числу.
IsOne	Указывает, равно ли значение текущего объекта BigInteger значению One.
IsPowerOfTwo	Указывает, равно ли значение текущего объекта BigInteger степени двух.
IsZero	Указывает, равно ли значение текущего объекта BigInteger значению Zero.
MinusOne	Получает значение, представляющее минус единицу (-1).
One	Получает значение, представляющее единицу (1).
Sign	Получает число, указывающее знак (минус, плюс или нуль) текущего объекта BigInteger.
Zero	Получает значение, представляющее 0 (нуль).

Методы

Abs(BigInteger)	Получает абсолютное значение объекта BigInteger.
Add(BigInteger, BigInteger)	Складывает два значения BigInteger и возвращает результат.
Clamp(BigInteger, BigInteger, BigInteger)	Приклоняет значение к инклюзивному минимальному и максимальному значению.
Compare(BigInteger, BigInteger)	Сравнивает два значения BigInteger и возвращает целое значение, которое показывает, больше или меньше первое значение по сравнению со вторым или равно ему.
CompareTo(BigInteger)	Сравнивает данный экземпляр с другим экземпляром BigInteger и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению указанного объекта.
CompareTo(Int64)	Сравнивает данный экземпляр с 64-разрядным знаковым целым числом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению 64-битового знакового целого числа.
CompareTo(Object)	Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.
CompareTo(UInt64)	Сравнивает данный экземпляр с 64-разрядным целым числом без знака и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим или большим по сравнению со значением 64-битового целого числа без знака или равным ему.
CopySign(BigInteger, BigInteger)	Копирует знак значения в знак другого значения.
Divide(BigInteger, BigInteger)	Делит одно значение BigInteger на другое и возвращает результат.
DivRem(BigInteger, BigInteger)	Вычисляет цитент и оставшуюся часть двух значений.
DivRem(BigInteger, BigInteger, BigInteger)	Делит одно значение BigInteger на другое, возвращает результат, а также возвращает остаток в виде параметра вывода.
Equals(BigInteger)	Возвращает значение, определяющее равны ли текущий экземпляр и указанный объект BigInteger.
Equals(Int64)	Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число со знаком.
Equals(Object)	Возвращает значение, определяющее, равны ли текущий экземпляр и указанный объект.
Equals(UInt64)	Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число без знака.
GetBitLength()	Возвращает число бит, необходимых для самого короткого представления текущего экземпляра в дополнительном коде без знакового бита.
GetByteCount(Boolean)	Возвращает число байтов, которое будет выводиться ToByteArray(Boolean, Boolean) и TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).
GetHashCode()	Возвращает хэш-код для текущего объекта BigInteger.
GreatestCommonDivisor(BigInteger, BigInteger)	Находит наибольший общий делитель двух значений BigInteger.
IsEvenInteger(BigInteger)	Определяет, представляет ли значение четное целочисленное число.
IsNegative(BigInteger)	Определяет, является ли значение отрицательным.
IsOddInteger(BigInteger)	Определяет, представляет ли значение нечетное целочисленное число.
IsPositive(BigInteger)	Определяет, является ли значение положительным.
IsPow2(BigInteger)	Определяет, является ли значение двумя.
LeadingZeroCount(BigInteger)	Вычисляет число начальных нулей в значении.
Log(BigInteger)	Возвращает натуральный логарифм (с основанием `e`) указанного числа.
Log(BigInteger, Double)	Возвращает логарифм указанного числа в системе счисления с указанным основанием.
Log10(BigInteger)	Возвращает логарифм с основанием 10 указанного числа.
Log2(BigInteger)	Вычисляет журнал 2 значения.
Max(BigInteger, BigInteger)	Возвращает наибольшее из двух значений BigInteger.
MaxMagnitude(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые больше.
Min(BigInteger, BigInteger)	Возвращает наименьшее из двух значений BigInteger.
MinMagnitude(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые меньше.
ModPow(BigInteger, BigInteger, BigInteger)	Выполняет модульное деление числа, возведенного в степень другого числа.
Multiply(BigInteger, BigInteger)	Возвращает произведение двух значений BigInteger.
Negate(BigInteger)	Меняет знак указанного значения BigInteger.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует представление числа, содержащегося в указанном диапазоне символов только для чтения в указанном стиле в его эквивалент BigInteger.
Parse(String)	Преобразует строковое представление числа в его эквивалент типа BigInteger.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.
Parse(String, NumberStyles)	Преобразует строковое представление числа с указанным стилем в его эквивалент в формате BigInteger.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.
PopCount(BigInteger)	Вычисляет количество битов, заданных в значении.
Pow(BigInteger, Int32)	Возводит значение BigInteger в заданную степень.
Remainder(BigInteger, BigInteger)	Выполняет целочисленное деление двух значений BigInteger и возвращает остаток.
RotateLeft(BigInteger, Int32)	Сменяет значение, оставленное заданной суммой.
RotateRight(BigInteger, Int32)	Поворачивает значение вправо на заданное значение.
Subtract(BigInteger, BigInteger)	Вычитает одно значение BigInteger из другого и возвращает результат.
ToByteArray()	Преобразует значение BigInteger в массив байтов.
ToByteArray(Boolean, Boolean)	Возвращает значение этого BigInteger в виде массива байтов, используя наименьшее количество байтов. Если значение равно нулю, возвращает массив из одного байта, элемент которого равен 0x00.
ToString()	Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление, используя указанные сведения об особенностях форматирования для данного языка и региональных параметров.
ToString(String)	Преобразует числовое значение текущего объекта BigInteger в эквивалентное строковое представление с использованием указанного формата.
ToString(String, IFormatProvider)	Преобразует значение текущего объекта BigInteger в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях формата для определенного языка и региональных параметров.
TrailingZeroCount(BigInteger)	Вычисляет число конечных нулей в значении.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Форматирует этот экземпляр длинного целого числа в диапазон символов.
TryParse(ReadOnlySpan<Char>, BigInteger)	Пытается преобразовать представление числа, содержащегося в указанном диапазоне символов только для чтения, в его эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.
TryParse(String, BigInteger)	Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.
TryParse(String, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Предпринимает попытку преобразования числа в формате, который определяется заданным стилем и языком и региональными параметрами, в эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Копирует значение этого BigInteger в парные байты с прямым порядком, используя наименьшее количество байт. Если значение равно нулю, возвращает один байт, элемент которого равен 0x00.

Операторы

Addition(BigInteger, BigInteger)	Складывает значения двух указанных объектов BigInteger.
BitwiseAnd(BigInteger, BigInteger)	Выполняет битовую операцию `And` для двух значений BigInteger.
BitwiseOr(BigInteger, BigInteger)	Выполняет битовую операцию `Or` для двух значений BigInteger.
Decrement(BigInteger)	Уменьшает значение BigInteger на 1.
Division(BigInteger, BigInteger)	Делит указанное значение BigInteger на другое указанное значение BigInteger, используя целочисленное деление.
Equality(BigInteger, BigInteger)	Возвращает значение, указывающее, равны ли значения двух объектов BigInteger.
Equality(BigInteger, Int64)	Возвращает значение, указывающее, равны ли значение BigInteger и длинное знаковое целое число.
Equality(BigInteger, UInt64)	Возвращает значение, указывающее, равны ли значение BigInteger и длинное целое число без знака.
Equality(Int64, BigInteger)	Возвращает значение, указывающее, равны ли длинное знаковое целое число и значение BigInteger.
Equality(UInt64, BigInteger)	Возвращает значение, указывающее, равны ли длинное целое число без знака и значение BigInteger.
ExclusiveOr(BigInteger, BigInteger)	Выполняет битовую операцию исключающего `Or` (`XOr`) для двух значений BigInteger.
Explicit(BigInteger to Byte)	Определяет явное преобразование объекта BigInteger в байтовое значение без знака.
Explicit(BigInteger to Char)	Явно преобразует большое целое число Char в значение.
Explicit(BigInteger to Decimal)	Определяет явное преобразование объекта BigInteger в значение Decimal.
Explicit(BigInteger to Double)	Определяет явное преобразование объекта BigInteger в значение Double.
Explicit(BigInteger to Half)	Явно преобразует большое целое число в Half значение.
Explicit(BigInteger to Int128)	Явно преобразует большое целое число в Int128 значение.
Explicit(BigInteger to Int16)	Определяет явное преобразование объекта BigInteger в значение 16-битового знакового целого числа.
Explicit(BigInteger to Int32)	Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа со знаком.
Explicit(BigInteger to Int64)	Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа со знаком.
Explicit(BigInteger to IntPtr)	Явно преобразует большое целое число в IntPtr значение.
Explicit(BigInteger to SByte)	Определяет явное преобразование объекта BigInteger в значение 8-битового числа со знаком. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int16.
Explicit(BigInteger to Single)	Определяет явное преобразование объекта BigInteger в значение числа с плавающей запятой одиночной точности.
Explicit(BigInteger to UInt128)	Явно преобразует большое целое число UInt128 в значение.
Explicit(BigInteger to UInt16)	Определяет явное преобразование объекта BigInteger в значение 16-битового целого числа без знака. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int32.
Explicit(BigInteger to UInt32)	Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа без знака. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int64.
Explicit(BigInteger to UInt64)	Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа без знака. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Double.
Explicit(BigInteger to UIntPtr)	Явно преобразует большое целое число UIntPtr в значение.
Explicit(Complex to BigInteger)	Явно преобразует Complex значение в большое целое число.
Explicit(Decimal to BigInteger)	Определяет явное преобразование объекта Decimal в значение BigInteger.
Explicit(Double to BigInteger)	Определяет явное преобразование значения Double в значение BigInteger.
Explicit(Half to BigInteger)	Явно преобразует Half значение в большое целое число.
Explicit(Single to BigInteger)	Определяет явное преобразование значения Single в значение BigInteger.
GreaterThan(BigInteger, BigInteger)	Возвращает значение, определяющее, действительно ли значение типа BigInteger больше другого значения типа BigInteger.
GreaterThan(BigInteger, Int64)	Возвращает значение, определяющее, действительно ли значение BigInteger больше значения 64-битового знакового целого числа.
GreaterThan(BigInteger, UInt64)	Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.
GreaterThan(Int64, BigInteger)	Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число больше или равно значению BigInteger.
GreaterThan(UInt64, BigInteger)	Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.
GreaterThanOrEqual(BigInteger, BigInteger)	Возвращает значение, определяющее, действительно ли значение типа BigInteger больше или равно другому значению типа BigInteger.
GreaterThanOrEqual(BigInteger, Int64)	Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового знакового целого числа.
GreaterThanOrEqual(BigInteger, UInt64)	Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового целого числа без знака.
GreaterThanOrEqual(Int64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число больше или равно значению BigInteger.
GreaterThanOrEqual(UInt64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака больше или равно значению BigInteger.
Implicit(Byte to BigInteger)	Определяет неявное преобразование значения типа byte без знака в значение BigInteger.
Implicit(Char to BigInteger)	Неявно преобразует Char значение в большое целое число.
Implicit(Int128 to BigInteger)	Неявно преобразует Int128 значение в большое целое число.
Implicit(Int16 to BigInteger)	Определяет неявное преобразование 16-битового знакового целого числа в значение BigInteger.
Implicit(Int32 to BigInteger)	Определяет неявное преобразование 32-разрядного целого числа со знаком в значение BigInteger.
Implicit(Int64 to BigInteger)	Определяет неявное преобразование 64-разрядного целого числа со знаком в значение BigInteger.
Implicit(IntPtr to BigInteger)	Неявно преобразует IntPtr значение в большое целое число.
Implicit(SByte to BigInteger)	Определяет неявное преобразование 8-битового знакового целого числа в значение BigInteger. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Неявно преобразует UInt128 значение в большое целое число.
Implicit(UInt16 to BigInteger)	Определяет неявное преобразование 16-битового целого числа без знака в значение BigInteger. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Определяет неявное преобразование 32-разрядного целого числа без знака в значение BigInteger. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	Определяет неявное преобразование 64-разрядного целого числа без знака в значение BigInteger. Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Double.
Implicit(UIntPtr to BigInteger)	Неявно преобразует UIntPtr значение в большое целое число.
Increment(BigInteger)	Увеличивает значение BigInteger на 1.
Inequality(BigInteger, BigInteger)	Возвращает значение, указывающее, имеют ли два объекта BigInteger различные значения.
Inequality(BigInteger, Int64)	Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное знаковое целое число не равны.
Inequality(BigInteger, UInt64)	Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное целое число без знака не равны.
Inequality(Int64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число и значение BigInteger не равны.
Inequality(UInt64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака и значение BigInteger не равны.
LeftShift(BigInteger, Int32)	Сдвигает значение BigInteger на указанное число битов влево.
LessThan(BigInteger, BigInteger)	Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше другого значения типа BigInteger.
LessThan(BigInteger, Int64)	Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового знакового целого числа.
LessThan(BigInteger, UInt64)	Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового целого числа без знака.
LessThan(Int64, BigInteger)	Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число меньше значения BigInteger.
LessThan(UInt64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше значения BigInteger.
LessThanOrEqual(BigInteger, BigInteger)	Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше или равно другому значению типа BigInteger.
LessThanOrEqual(BigInteger, Int64)	Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному знаковому целому числу.
LessThanOrEqual(BigInteger, UInt64)	Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному целому числу без знака.
LessThanOrEqual(Int64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число меньше или равно значению BigInteger.
LessThanOrEqual(UInt64, BigInteger)	Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше или равно значению BigInteger.
Modulus(BigInteger, BigInteger)	Возвращает остаток от деления двух заданных значений BigInteger.
Multiply(BigInteger, BigInteger)	Умножает два заданных значения BigInteger.
OnesComplement(BigInteger)	Возвращает результат битовой операции дополнения до единицы для значения BigInteger.
RightShift(BigInteger, Int32)	Сдвигает значение BigInteger на указанное число битов вправо.
Subtraction(BigInteger, BigInteger)	Вычитает значение BigInteger из другого значения BigInteger.
UnaryNegation(BigInteger)	Меняет знак указанного значения BigInteger.
UnaryPlus(BigInteger)	Возвращает значение операнда BigInteger. (Знак операнда не изменяется.)
UnsignedRightShift(BigInteger, Int32)	Сдвигает значение вправо на заданное значение.

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

IBinaryInteger<BigInteger>.GetByteCount()	Возвращает число байтов, которые будут записаны в составе TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<BigInteger>.GetShortestBitLength()	Возвращает длину (в битах) от кратчайшего дополнительного представления текущего значения.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается записать текущее значение в минимальном формате в заданный диапазон.
IComparable.CompareTo(Object)	Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.

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