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

Определение

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

System.Numerics

Сборка:

System.Runtime.Numerics.dll

Инициализирует новый экземпляр структуры BigInteger.

Перегрузки

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

BigInteger(Byte[])

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

BigInteger.cs

Важно!

Этот API несовместим с CLS.

Инициализирует новый экземпляр структуры BigInteger, используя значения в массиве типа byte.

public:
 BigInteger(cli::array <System::Byte> ^ value);

[System.CLSCompliant(false)]
public BigInteger (byte[] value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger

Public Sub New (value As Byte())

Параметры

value

Byte[]

Массив значений типа byte в прямом порядке байтов.

Атрибуты

CLSCompliantAttribute

Исключения

ArgumentNullException

value имеет значение null.

Примеры

В следующем примере создается BigInteger экземпляр объекта из 5-элементного байтового массива со значением {5, 4, 3, 2, 1}. Затем в консоли отображается BigInteger значение, представленное как десятичными, так и шестнадцатеричными числами. Сравнение входного массива с текстовыми выходными данными позволяет понять, почему перегрузка конструктора BigInteger класса создает BigInteger объект, значение которого 4328719365 (или 0x102030405). Первый элемент массива байтов, значение которого равно 5, определяет значение байта BigInteger объекта с наименьшим порядком, который является 0x05. Второй элемент массива байтов, значение которого равно 4, определяет значение второго байта BigInteger объекта , который является 0x04 и т. д.

byte[] bytes = { 5, 4, 3, 2, 1 };
BigInteger number = new BigInteger(bytes);
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number);
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

let bytes = [| 5uy; 4uy; 3uy; 2uy; 1uy |]
let number = new BigInteger(bytes)
printfn $"The value of number is {number} (or 0x{number:x})."
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

Dim bytes() As Byte = { 5, 4, 3, 2, 1 }
Dim number As New BigInteger(bytes)
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number) 
' The example displays the following output:
'    The value of number is 4328719365 (or 0x102030405).

В следующем примере создаются экземпляры положительных и отрицательных BigInteger значений, передаются в ToByteArray метод , а затем восстанавливают исходные BigInteger значения из результирующего массива байтов. Обратите внимание, что эти два значения представлены идентичными массивами байтов. Единственное различие между ними заключается в наиболее значительном бите последнего элемента в массиве байтов. Этот бит устанавливается (значение байта 0xFF), если массив создается из отрицательного BigInteger значения. Бит не задан (значение байта равно нулю), если массив создается из положительного BigInteger значения.

// Instantiate BigInteger values.
BigInteger positiveValue = BigInteger.Parse("4713143110832790377889");
BigInteger negativeValue = BigInteger.Add(-Int64.MaxValue, -60000);
BigInteger positiveValue2, negativeValue2;

// Create two byte arrays.
byte[] positiveBytes = positiveValue.ToByteArray();
byte[] negativeBytes = negativeValue.ToByteArray();

// Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue);
foreach (byte byteValue in negativeBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue2 = new BigInteger(negativeBytes);
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2);
Console.WriteLine();

// Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue);
foreach (byte byteValue in positiveBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue2 = new BigInteger(positiveBytes);
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2);
Console.WriteLine();
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

// Instantiate BigInteger values.
let positiveValue = BigInteger.Parse "4713143110832790377889"
let negativeValue = BigInteger.Add(-Int64.MaxValue, -60000)

// Create two byte arrays.
let positiveBytes = positiveValue.ToByteArray()
let negativeBytes = negativeValue.ToByteArray()

// Instantiate new BigInteger from negativeBytes array.
printf $"Converted {negativeValue:N0} to the byte array "

for byteValue in negativeBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let negativeValue2 = bigint negativeBytes
printfn $"Converted the byte array to {negativeValue2:N0}"
printfn ""

// Instantiate new BigInteger from positiveBytes array.
printf $"Converted {positiveValue:N0} to the byte array "

for byteValue in positiveBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let positiveValue2 = new BigInteger(positiveBytes)
printfn $"Converted the byte array to {positiveValue2:N0}"
printfn ""
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

' Instantiate BigInteger values.
Dim positiveValue As BigInteger = BigInteger.Parse("4713143110832790377889")
Dim negativeValue As BigInteger = BigInteger.Add(-Int64.MaxValue, -60000) 
Dim positiveValue2, negativeValue2 As BigInteger

' Create two byte arrays.
Dim positiveBytes() As Byte = positiveValue.ToByteArray()
Dim negativeBytes() As Byte = negativeValue.ToByteArray()

' Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue)
For Each byteValue As Byte In negativeBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
negativeValue2 = New BigInteger(negativeBytes)
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2)
Console.WriteLine()

' Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue)
For Each byteValue As Byte In positiveBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
positiveValue2 = New BigInteger(positiveBytes)
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2)
Console.WriteLine()
' The example displays the following output:
'    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
'    Converted the byte array to -9,223,372,036,854,835,807
'    
'    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
'    Converted the byte array to 4,713,143,110,832,790,377,889

В следующем примере показано, как убедиться, что положительное значение не было неправильно создано как отрицательное значение путем добавления байта, значение которого равно нулю, в конец массива.

ulong originalNumber = UInt64.MaxValue;
byte[] bytes = BitConverter.GetBytes(originalNumber);
if (originalNumber > 0 && (bytes[bytes.Length - 1] & 0x80) > 0)
{
   byte[] temp = new byte[bytes.Length];
   Array.Copy(bytes, temp, bytes.Length);
   bytes = new byte[temp.Length + 1];
   Array.Copy(temp, bytes, temp.Length);
}

BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.",
                  originalNumber, newNumber);
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

let originalNumber = UInt64.MaxValue
let mutable bytes = BitConverter.GetBytes originalNumber

if originalNumber > 0uL && (bytes[bytes.Length - 1] &&& 0x80uy) > 0uy then
    let temp = Array.zeroCreate bytes.Length

    Array.Copy(bytes, temp, bytes.Length)
    bytes <- Array.zeroCreate (temp.Length + 1)
    Array.Copy(temp, bytes, temp.Length)

let newNumber = bigint bytes
printfn $"Converted the UInt64 value {originalNumber:N0} to {newNumber:N0}."
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Dim originalNumber As ULong = UInt64.MaxValue
' Convert an unsigned integer to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalNumber)
' Determine whether the MSB of the highest-order byte is set.
If originalNumber > 0 And (bytes(bytes.Length - 1) And &h80) > 0 Then
   ' If the MSB is set, add one zero-value byte to the end of the array.
   ReDim Preserve bytes(bytes.Length)
End If

Dim newNumber As New BigInteger(bytes)
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.", 
                  originalNumber, newNumber) 
' The example displays the following output:
'    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Комментарии

Отдельные байты в массиве value должны быть в байтовом порядке с наименьшим порядком до байтов самого высокого порядка. Например, числовое значение 1,000,000,000,000 представляется, как показано в следующей таблице:

Шестнадцатеричная строка	E8D4A51000
Массив байтов (сначала самый низкий индекс)	00 10 A5 D4 E8 00

Большинство методов, преобразующих числовые значения в массивы байтов, таких как BigInteger.ToByteArray и BitConverter.GetBytes, возвращают массивы байтов в порядке байтов.

Конструктор ожидает, что положительные значения в массиве байтов будут использовать представление знака и величины, а отрицательные значения — представление двух дополнений. Иными словами, если задан бит самого высокого порядка байта в value , результирующее BigInteger значение будет отрицательным. В зависимости от источника массива байтов это может привести к неправильному толкованию положительного значения как отрицательного. Массивы байтов обычно создаются следующими способами:

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

• Путем вызова метода и передачи BitConverter.GetBytes ему целого числа со знаком в качестве параметра. Так как целые числа со знаком обрабатывают как представление знака и величины, так и представление дополнения двух, вероятность неправильного толкования положительного значения как отрицательного отсутствует.

• Путем вызова BitConverter.GetBytes метода и передачи ему целого числа без знака в качестве параметра. Поскольку целые числа без знака представлены только их величиной, положительные значения могут быть неправильно интерпретированы как отрицательные значения. Чтобы избежать такого неправильного толкования, можно добавить нулевое значение в конец массива. Пример в следующем разделе содержит иллюстрацию.

• Путем динамического или статического создания массива байтов без обязательного вызова любого из предыдущих методов или путем изменения существующего массива байтов. Чтобы избежать неправильного толкования положительных значений как отрицательных, можно добавить нулевое байтовое значение в конец массива.

Если value является пустым Byte массивом, новый BigInteger объект инициализируется значением BigInteger.Zero. Если value имеет значение null, конструктор создает исключение ArgumentNullException.

См. также раздел

• ToByteArray()

BigInteger(Decimal)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя значение Decimal.

public:
 BigInteger(System::Decimal value);

public BigInteger (decimal value);

new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger

Public Sub New (value As Decimal)

Параметры

value

Decimal

Десятичное число.

Примеры

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

decimal[] decimalValues = { -1790.533m, -15.1514m, 18903.79m, 9180098.003m };
foreach (decimal decimalValue in decimalValues)
{
   BigInteger number = new BigInteger(decimalValue);
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue);
}
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

let decimalValues = [ -1790.533m; -15.1514m; 18903.79m; 9180098.003m ]

for decimalValue in decimalValues do
    let number = bigint decimalValue
    printfn $"Instantiated BigInteger value {number} from the Decimal value {decimalValue}."
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Dim decimalValues() As Decimal = { -1790.533d, -15.1514d, 18903.79d, 9180098.003d }
For Each decimalValue As Decimal In decimalValues
   Dim number As New BigInteger(decimalValue)
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue)
Next                 
' The example displays the following output:
'    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
'    Instantiated BigInteger value -15 from the Decimal value -15.1514.
'    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
'    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Комментарии

Результат вызова этого конструктора идентичен явному присвоению Decimal значения переменной BigInteger .

Вызов этого конструктора может привести к потере данных; любая дробная часть value усекается при создании экземпляра BigInteger объекта .

BigInteger(Double)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой двойной точности.

public:
 BigInteger(double value);

public BigInteger (double value);

new System.Numerics.BigInteger : double -> System.Numerics.BigInteger

Public Sub New (value As Double)

Параметры

value

Double

Значение с плавающей точкой двойной точности.

Исключения

OverflowException

value имеет значение NaN, NegativeInfinity или PositiveInfinity.

Примеры

В следующем примере показано использование конструктора BigInteger(Double) для создания экземпляра BigInteger объекта . В нем также показана потеря точности, которая может произойти при использовании Double типа данных. Объекту Double присваивается большое значение, которое затем присваивается объекту BigInteger . Как видно из выходных данных, это назначение связано с потерей точности. Затем оба значения увеличиваются на единицу. В выходных BigInteger данных показано, что объект отражает измененное значение, а Double объект — нет.

// Create a BigInteger from a large double value.
double doubleValue = -6e20;
BigInteger bigIntValue = new BigInteger(doubleValue);
Console.WriteLine("Original Double value: {0:N0}", doubleValue);
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue);
// Increment and then display both values.
doubleValue++;
bigIntValue += BigInteger.One;
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue);
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue);
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

// Create a BigInteger from a large double value.
let doubleValue = -6e20
let bigIntValue = bigint doubleValue
printfn $"Original Double value: {doubleValue:N0}"
printfn $"Original BigInteger value: {bigIntValue:N0}"
// Increment and then display both values.
let doubleValue = doubleValue + 1.
let bigIntValue = bigIntValue + BigInteger.One
printfn $"Incremented Double value: {doubleValue:N0}"
printfn $"Incremented BigInteger value: {bigIntValue:N0}"
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

' Create a BigInteger from a large double value.
Dim doubleValue As Double = -6e20
Dim bigIntValue As New BigInteger(doubleValue)
Console.WriteLine("Original Double value: {0:N0}", doubleValue)
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue)
' Increment and then display both values.
doubleValue += 1
bigIntValue += BigInteger.One
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue)
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue)
' The example displays the following output:
'    Original Double value: -600,000,000,000,000,000,000
'    Original BigInteger value: -600,000,000,000,000,000,000
'    Incremented Double value: -600,000,000,000,000,000,000
'    Incremented BigInteger value: -599,999,999,999,999,999,999

Комментарии

Любая дробная часть value параметра усекается при создании экземпляра BigInteger объекта .

Из-за отсутствия точности Double типа данных вызов этого конструктора может привести к потере данных.

Значение, полученное BigInteger в результате вызова этого конструктора, идентично значению, полученному в результате явного Double присвоения значения BigInteger.

BigInteger(Int32)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное знаковое целое число.

public:
 BigInteger(int value);

public BigInteger (int value);

new System.Numerics.BigInteger : int -> System.Numerics.BigInteger

Public Sub New (value As Integer)

Параметры

value

Int32

32-разрядное знаковое целое число.

Примеры

В следующем примере вызывается BigInteger(Int32) конструктор для создания BigInteger экземпляров значений из массива 32-разрядных целых чисел. Он также использует неявное преобразование для присвоения каждому 32-разрядному целочисленного значения переменной BigInteger . Затем он сравнивает два значения, чтобы установить, что результирующее BigInteger значение совпадает.

int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                   Int32.MaxValue };
BigInteger constructed, assigned;

foreach (int number in integers)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

let integers = [ Int32.MinValue; -10534; -189; 0; 17; 113439; Int32.MaxValue ]

for number in integers do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

Dim integers() As Integer = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                              Int32.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Integer In integers
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -2147483648 = -2147483648: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       2147483647 = 2147483647: True

Комментарии

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

Значение, полученное BigInteger в результате вызова этого конструктора, идентично значению, полученному Int32 в результате присвоения значения BigInteger.

Структура BigInteger не включает конструкторы с параметром типа Byte, Int16, SByteили UInt16. Однако Int32 тип поддерживает неявное преобразование 8- и 16-разрядных целых чисел со знаком и без знака в 32-разрядные целые числа со знаком. В результате этот конструктор вызывается, если value является одним из этих четырех целочисленных типов.

BigInteger(Int64)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число со знаком.

public:
 BigInteger(long value);

public BigInteger (long value);

new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger

Public Sub New (value As Long)

Параметры

value

Int64

64-разрядное целое число со знаком.

Примеры

В следующем примере вызывается BigInteger(Int64) конструктор для создания BigInteger экземпляров значений из массива 64-разрядных целых чисел. Он также использует неявное преобразование для присвоения каждому 64-разрядному целочисленного значения переменной BigInteger . Затем он сравнивает два значения, чтобы установить, что результирующее BigInteger значение совпадает.

long[] longs = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                 Int64.MaxValue };
BigInteger constructed, assigned;

foreach (long number in longs)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

let longs = [ Int64.MinValue; -10534; -189; 0; 17; 113439; Int64.MaxValue ]

for number in longs do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

Dim longs() As Long = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                              Int64.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Long In longs
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -2147483648 = -2147483648: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       2147483647 = 2147483647: True

Комментарии

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

Значение, полученное BigInteger в результате вызова этого конструктора, идентично значению, полученному Int64 в результате присвоения значения BigInteger.

BigInteger(Single)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой одиночной точности.

public:
 BigInteger(float value);

public BigInteger (float value);

new System.Numerics.BigInteger : single -> System.Numerics.BigInteger

Public Sub New (value As Single)

Параметры

value

Single

Значение с плавающей точкой одинарной точности.

Исключения

OverflowException

value имеет значение NaN, NegativeInfinity или PositiveInfinity.

Примеры

В следующем примере показано использование конструктора BigInteger(Single) для создания экземпляра BigInteger объекта . В нем также показана потеря точности, которая может произойти при использовании Single типа данных. Объекту Single присваивается большое отрицательное значение, которое затем присваивается объекту BigInteger . Как видно из выходных данных, это назначение связано с потерей точности. Затем оба значения увеличиваются на единицу. Выходные данные показывают, что BigInteger объект отражает измененное значение, а Single объект — нет.

// Create a BigInteger from a large negative Single value
float negativeSingle = Single.MinValue;
BigInteger negativeNumber = new BigInteger(negativeSingle);

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));

negativeSingle++;
negativeNumber++;

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

// Create a BigInteger from a large negative Single value
let negativeSingle = Single.MinValue
let negativeNumber = bigint negativeSingle

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""

let negativeSingle = negativeSingle + 1f
let negativeNumber = negativeNumber + 1I

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

' Create a BigInteger from a large negative Single value
Dim negativeSingle As Single = Single.MinValue
Dim negativeNumber As New BigInteger(negativeSingle)

Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))

negativeSingle += 1
negativeNumber += 1
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
' The example displays the following output:
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,440
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,439

Комментарии

Любая дробная часть value параметра усекается при создании экземпляра BigInteger объекта.

Из-за отсутствия точности Single типа данных вызов этого конструктора может привести к потере данных.

Значение, полученное BigInteger при вызове этого конструктора, идентично значению, которое является результатом явного Single присвоения значения BigInteger.

BigInteger(UInt32)

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

BigInteger.cs

Важно!

Этот API несовместим с CLS.

Альтернативный вариант, совместимый с CLS

System.Numerics.BigInteger.BigInteger(Int64)

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное целое число без знака.

public:
 BigInteger(System::UInt32 value);

[System.CLSCompliant(false)]
public BigInteger (uint value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger

Public Sub New (value As UInteger)

Параметры

value

UInt32

32-разрядное целое значение без знака.

Атрибуты

CLSCompliantAttribute

Примеры

В следующем примере используются BigInteger(UInt32) конструктор и инструкция присваивания для инициализации BigInteger значений из массива 32-разрядных целых чисел без знака. Затем сравнивается два значения, чтобы продемонстрировать, что два метода инициализации значения дают одинаковые BigInteger результаты.

uint[] unsignedValues = { 0, 16704, 199365, UInt32.MaxValue };
foreach (uint unsignedValue in unsignedValues)
{
   BigInteger constructedNumber = new BigInteger(unsignedValue);
   BigInteger assignedNumber = unsignedValue;
   if (constructedNumber.Equals(assignedNumber))
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber);
   else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber);
}
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

let unsignedValues = [ 0u; 16704u; 199365u; UInt32.MaxValue ]

for unsignedValue in unsignedValues do
    let constructedNumber = bigint unsignedValue
    let assignedNumber = unsignedValue

    if constructedNumber.Equals assignedNumber then
        printfn $"Both methods create a BigInteger whose value is {constructedNumber:N0}."
    else
        printfn $"{constructedNumber:N0} ≠ {assignedNumber:N0}"
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

Dim unsignedValues() As UInteger = { 0, 16704, 199365, UInt32.MaxValue }
For Each unsignedValue As UInteger In unsignedValues
   Dim constructedNumber As New BigInteger(unsignedValue)
   Dim assignedNumber As BigInteger = unsignedValue
   If constructedNumber.Equals(assignedNumber) Then
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber)
   Else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber)
   End If                         
Next
' The example displays the following output:
'    Both methods create a BigInteger whose value is 0.
'    Both methods create a BigInteger whose value is 16,704.
'    Both methods create a BigInteger whose value is 199,365.
'    Both methods create a BigInteger whose value is 4,294,967,295.

Комментарии

При создании BigInteger экземпляра с помощью этого конструктора точность не теряется.

Значение, полученное BigInteger при вызове этого конструктора, идентично значению, которое является результатом UInt32 присвоения значения BigInteger.

BigInteger(UInt64)

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

BigInteger.cs

Важно!

Этот API несовместим с CLS.

Альтернативный вариант, совместимый с CLS

System.Numerics.BigInteger.BigInteger(Double)

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число без знака.

public:
 BigInteger(System::UInt64 value);

[System.CLSCompliant(false)]
public BigInteger (ulong value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger

Public Sub New (value As ULong)

Параметры

value

UInt64

64-разрядное целое число без знака.

Атрибуты

CLSCompliantAttribute

Примеры

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

ulong unsignedValue = UInt64.MaxValue;
BigInteger number = new BigInteger(unsignedValue);
Console.WriteLine(number.ToString("N0"));
// The example displays the following output:
//       18,446,744,073,709,551,615

let unsignedValue = UInt64.MaxValue
let number = bigint unsignedValue
printfn $"{number:N0}"
// The example displays the following output:
//       18,446,744,073,709,551,615

Dim unsignedValue As ULong = UInt64.MaxValue
Dim number As New BigInteger(unsignedValue)
Console.WriteLine(number.ToString("N0"))       
' The example displays the following output:
'       18,446,744,073,709,551,615

Комментарии

При создании BigInteger экземпляра с помощью этого конструктора точность не теряется.

Значение, полученное BigInteger при вызове этого конструктора, идентично значению, которое является результатом UInt64 присвоения значения BigInteger.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

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

BigInteger.cs

Инициализирует новый экземпляр структуры BigInteger, используя значения в диапазоне байтов, доступном только для чтения, и при необходимости указывая кодировку подписи и порядок следования байтов.

public BigInteger (ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);

new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigInteger

Public Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)

Параметры

value

ReadOnlySpan<Byte>

Доступный только для чтения диапазон байтов, представляющий длинное целое число.

isUnsigned

Boolean

true, чтобы указать, что value использует неподписанную кодировку; в противном случае — false (значение по умолчанию).

isBigEndian

Boolean

true Значение , указывающее value , что имеет большой порядок байтов; в противном случае false — значение по умолчанию.