BigInteger Структура

Определение

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

System.Numerics

Сборки:

netstandard.dll, System.Runtime.Numerics.dll

Исходный код:

BigInteger.cs

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

public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, IUtf8SpanParsable<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, bool>, 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, bool>, 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, int, 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 readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, IUtf8SpanParsable<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,bool>, 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,bool>, 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,int,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>

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, bool>
    interface IEqualityOperators<BigInteger, BigInteger, bool>
    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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IShiftOperators<BigInteger, int, BigInteger>
    interface ISignedNumber<BigInteger>

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, Boolean), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger, Boolean), 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, Integer, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger), IUtf8SpanParsable(Of BigInteger)

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

Object

ValueType

BigInteger

Реализации

IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanFormattable ISpanParsable<BigInteger> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<BigInteger> IUtf8SpanParsable<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> IComparisonOperators<BigInteger,BigInteger,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<BigInteger,BigInteger,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> 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> IShiftOperators<BigInteger,Int32,BigInteger> IShiftOperators<TSelf,Int32,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, которые имеют диапазон, указанный свойствами MinValue и MaxValue.

Note

Так как тип 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 {newBigInt} (or 0x{newBigInt:x}).");
  // 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 '{positiveString}' to a BigInteger value.");
  }
  
  if (BigInteger.TryParse(negativeString, out negBigInt))
    Console.WriteLine(negBigInt);
  else
     Console.WriteLine($"Unable to convert the string '{negativeString}' to a BigInteger value.");
  
  // 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 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 и назначает его значение больше предыдущего значения. Затем этот новый объект возвращается вызывающему.

Note

Другие числовые типы в .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 296. Так как самый значительный бит последнего байта в этом массиве включен, значение массива байтов будет интерпретировано конструктором 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 {negativeNumber:N0} to {negativeHex} back to {negativeNumber2:N0}.");
Console.WriteLine($"Converted {positiveNumber:N0} to {positiveHex} back to {positiveNumber2:N0}.");
// 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 ByteHexExample2
{
    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 {positiveNumber} to {hexValue1.Value} and back to {positiveBigInt}.");

        hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
        negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
        Console.WriteLine($"Converted {negativeNumber} to {hexValue2.Value} and back to {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 Example2
    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 структуры с помощью значений в массиве байтов.
BigInteger(Decimal)	Инициализирует новый экземпляр BigInteger структуры с помощью Decimal значения.
BigInteger(Double)	Инициализирует новый экземпляр BigInteger структуры с помощью значения с плавающей запятой двойной точности.
BigInteger(Int32)	Инициализирует новый экземпляр структуры с помощью 32-разрядного BigInteger целого числа со знаком.
BigInteger(Int64)	Инициализирует новый экземпляр структуры с помощью 64-разрядного BigInteger целого числа со знаком.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Инициализирует новый экземпляр BigInteger структуры с помощью значений в диапазоне только для чтения байтов и при необходимости указывает кодировку подписывания и порядок байтов концевости.
BigInteger(Single)	Инициализирует новый экземпляр BigInteger структуры с помощью значения с плавающей запятой с одной точностью.
BigInteger(UInt32)	Инициализирует новый экземпляр структуры с помощью 32-разрядного BigInteger целого числа без знака.
BigInteger(UInt64)	Инициализирует новый экземпляр BigInteger структуры с 64-разрядным целым числом без знака.

Свойства

Имя	Описание
IsEven	Указывает, является ли значение текущего BigInteger объекта четным числом.
IsOne	Указывает, является BigIntegerли значение текущего One объекта.
IsPowerOfTwo	Указывает, является ли значение текущего BigInteger объекта двумя.
IsZero	Указывает, является BigIntegerли значение текущего Zero объекта.
MinusOne	Возвращает значение, представляющее число отрицательное значение (-1).
One	Возвращает значение, представляющее номер 1 (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-разрядным целым числом без знака и возвращает целое число, указывающее, меньше ли значение этого экземпляра, равное или больше значения целого числа без знака.
CopySign(BigInteger, BigInteger)	Копирует знак значения в знак другого значения.
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы представляющего диапазона текущего типа.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усечение всех значений, которые выходят за пределы представляющего диапазона текущего типа.
Divide(BigInteger, BigInteger)	Делит одно BigInteger значение на другое и возвращает результат.
DivRem(BigInteger, BigInteger, BigInteger)	Делит одно BigInteger значение на другое, возвращает результат и возвращает оставшуюся часть в выходном параметре.
DivRem(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, Double)	Возвращает логарифм указанного числа в указанной базе.
Log(BigInteger)	Возвращает естественный (базовый e) логарифм указанного числа.
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, IFormatProvider)	Преобразует строковое представление числа в указанном формате языка и региональных параметров в эквивалентный.BigInteger
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентный.BigInteger
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном стиле в его BigInteger эквивалент.
Parse(String)	Преобразует строковое представление числа в его 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, IFormatProvider)	Преобразует числовое значение текущего BigInteger объекта в эквивалентное строковое представление с помощью указанного формата и сведений о формате и региональных параметрах.
ToString(String)	Преобразует числовое значение текущего 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)	Возвращает значение, указывающее, превышает BigInteger ли 64-разрядное целое число со знаком.
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)	Определяет неявное преобразование неназначенных байтов в 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)	Возвращает значение, указывающее, меньше BigInteger ли 64-разрядное целое число со знаком.
LessThan(UInt64, BigInteger)	Возвращает значение, указывающее, меньше BigInteger ли 64-разрядное целое число без знака.
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)	Вычитает значение из другого BigIntegerBigInteger значения.
UnaryNegation(BigInteger)	Отрицает указанное значение BigInteger.
UnaryPlus(BigInteger)	Возвращает значение BigInteger операнда. (Знак операнда не изменяется.)
UnsignedRightShift(BigInteger, Int32)	Сдвигает значение вправо по заданной сумме.

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

Имя	Описание
IAdditiveIdentity<BigInteger,BigInteger>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryInteger<BigInteger>.GetByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<BigInteger>.GetShortestBitLength()	Возвращает длину (в битах) в кратчайшем представлении текущего значения.
IBinaryInteger<BigInteger>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Представляет произвольно большое целое число со знаком.
IBinaryInteger<BigInteger>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Представляет произвольно большое целое число со знаком.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается написать текущее значение в маленьком формате в заданном диапазоне.
IBinaryNumber<BigInteger>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IMultiplicativeIdentity<BigInteger,BigInteger>.MultiplicativeIdentity	Возвращает умножающее удостоверение текущего типа.
INumber<BigInteger>.MaxNumber(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые больше и возвращают другое значение, если одно входное значение.NaN
INumber<BigInteger>.MinNumber(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые меньше и возвращают другое значение, если один входной NaN.
INumber<BigInteger>.Sign(BigInteger)	Вычисляет знак значения.
INumberBase<BigInteger>.IsCanonical(BigInteger)	Определяет, находится ли значение в его каноническом представлении.
INumberBase<BigInteger>.IsComplexNumber(BigInteger)	Определяет, представляет ли значение сложное число.
INumberBase<BigInteger>.IsFinite(BigInteger)	Определяет, является ли значение конечным.
INumberBase<BigInteger>.IsImaginaryNumber(BigInteger)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<BigInteger>.IsInfinity(BigInteger)	Определяет, является ли значение бесконечным.
INumberBase<BigInteger>.IsInteger(BigInteger)	Определяет, представляет ли значение целочисленное число.
INumberBase<BigInteger>.IsNaN(BigInteger)	Определяет, является ли значение naN.
INumberBase<BigInteger>.IsNegativeInfinity(BigInteger)	Определяет, является ли значение отрицательным бесконечностью.
INumberBase<BigInteger>.IsNormal(BigInteger)	Определяет, является ли значение нормальным.
INumberBase<BigInteger>.IsPositiveInfinity(BigInteger)	Определяет, является ли значение положительным бесконечностью.
INumberBase<BigInteger>.IsRealNumber(BigInteger)	Определяет, представляет ли значение реальное число.
INumberBase<BigInteger>.IsSubnormal(BigInteger)	Определяет, является ли значение ненормальным.
INumberBase<BigInteger>.IsZero(BigInteger)	Определяет, равно ли значение нулю.
INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые имеют больше величины и возвращают другое значение, если один входной NaN.
INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger, BigInteger)	Сравнивает два значения с вычислениями, которые имеют меньшее значение и возвращает другое значение, если один входной NaN.
INumberBase<BigInteger>.MultiplyAddEstimate(BigInteger, BigInteger, BigInteger)	Вычисляет оценку (left * right) + . addend
INumberBase<BigInteger>.Radix	Возвращает радикс или базу для типа.
INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther, BigInteger)	Представляет произвольно большое целое число со знаком.
INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther, BigInteger)	Представляет произвольно большое целое число со знаком.
INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther, BigInteger)	Представляет произвольно большое целое число со знаком.
INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усечение любых значений, которые выходят за пределы представляющего диапазона текущего типа.
ISignedNumber<BigInteger>.NegativeOne	Возвращает значение -1 типа.