BigInteger 结构

定义

表示任意大的带符号整数。

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable
public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, System::Numerics::IAdditionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IAdditiveIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IBinaryInteger<System::Numerics::BigInteger>, System::Numerics::IBinaryNumber<System::Numerics::BigInteger>, System::Numerics::IBitwiseOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IComparisonOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IDecrementOperators<System::Numerics::BigInteger>, System::Numerics::IDivisionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IEqualityOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IIncrementOperators<System::Numerics::BigInteger>, System::Numerics::IModulusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplicativeIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplyOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::INumber<System::Numerics::BigInteger>, System::Numerics::INumberBase<System::Numerics::BigInteger>, System::Numerics::IShiftOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::ISignedNumber<System::Numerics::BigInteger>, System::Numerics::ISubtractionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryNegationOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryPlusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable
public readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, System.Numerics.IAdditionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IBinaryInteger<System.Numerics.BigInteger>, System.Numerics.IBinaryNumber<System.Numerics.BigInteger>, System.Numerics.IBitwiseOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IComparisonOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IDecrementOperators<System.Numerics.BigInteger>, System.Numerics.IDivisionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IEqualityOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IIncrementOperators<System.Numerics.BigInteger>, System.Numerics.IModulusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplyOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.INumber<System.Numerics.BigInteger>, System.Numerics.INumberBase<System.Numerics.BigInteger>, System.Numerics.IShiftOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.ISignedNumber<System.Numerics.BigInteger>, System.Numerics.ISubtractionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryNegationOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryPlusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable
type BigInteger = struct
    interface IFormattable
    interface IParsable<BigInteger>
    interface ISpanFormattable
    interface ISpanParsable<BigInteger>
    interface IAdditionOperators<BigInteger, BigInteger, BigInteger>
    interface IAdditiveIdentity<BigInteger, BigInteger>
    interface IBinaryInteger<BigInteger>
    interface IBinaryNumber<BigInteger>
    interface IBitwiseOperators<BigInteger, BigInteger, BigInteger>
    interface IComparisonOperators<BigInteger, BigInteger>
    interface IEqualityOperators<BigInteger, BigInteger>
    interface IDecrementOperators<BigInteger>
    interface IDivisionOperators<BigInteger, BigInteger, BigInteger>
    interface IIncrementOperators<BigInteger>
    interface IModulusOperators<BigInteger, BigInteger, BigInteger>
    interface IMultiplicativeIdentity<BigInteger, BigInteger>
    interface IMultiplyOperators<BigInteger, BigInteger, BigInteger>
    interface INumber<BigInteger>
    interface INumberBase<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IShiftOperators<BigInteger, BigInteger>
    interface ISignedNumber<BigInteger>
[<System.Serializable>]
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable
Public Structure BigInteger
Implements IAdditionOperators(Of BigInteger, BigInteger, BigInteger), IAdditiveIdentity(Of BigInteger, BigInteger), IBinaryInteger(Of BigInteger), IBinaryNumber(Of BigInteger), IBitwiseOperators(Of BigInteger, BigInteger, BigInteger), IComparable(Of BigInteger), IComparisonOperators(Of BigInteger, BigInteger), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger), IEquatable(Of BigInteger), IIncrementOperators(Of BigInteger), IModulusOperators(Of BigInteger, BigInteger, BigInteger), IMultiplicativeIdentity(Of BigInteger, BigInteger), IMultiplyOperators(Of BigInteger, BigInteger, BigInteger), INumber(Of BigInteger), INumberBase(Of BigInteger), IParsable(Of BigInteger), IShiftOperators(Of BigInteger, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger)
继承
BigInteger
属性
实现
IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanParsable<BigInteger> ISpanParsable<TSelf> IAdditionOperators<BigInteger,BigInteger,BigInteger> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<BigInteger,BigInteger> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<BigInteger> IBinaryNumber<BigInteger> IBinaryNumber<TSelf> IBitwiseOperators<BigInteger,BigInteger,BigInteger> IBitwiseOperators<TSelf,TSelf,TSelf> System.Numerics.IComparisonOperators<BigInteger,BigInteger> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<BigInteger,BigInteger> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> IIncrementOperators<BigInteger> IIncrementOperators<TSelf> IModulusOperators<BigInteger,BigInteger,BigInteger> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<BigInteger,BigInteger> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<BigInteger,BigInteger,BigInteger> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<BigInteger> INumber<TSelf> INumberBase<BigInteger> INumberBase<TSelf> System.Numerics.IShiftOperators<BigInteger,BigInteger> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf>

注解

BigInteger 类型是一个不可变类型,表示一个任意大整数,其理论上的值没有上限或下限。 类型的成员BigInteger (其他整型类型 (Byte、、Int16Int32UInt16UInt32Int64SByte、和UInt64类型) 紧密并行。 此类型不同于.NET Framework中的其他整型类型,这些类型具有其MinValueMaxValue属性指示的范围。

备注

BigInteger由于类型不可变 (看到可变性和 BigInteger 结构) ,并且它没有上限或下限,因此,对于导致值增长过大的任何操作,可能会引发该OutOfMemoryExceptionBigInteger操作。

实例化 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 并将其赋值,就像任何数值类型一样,只要该值是整型类型。 以下示例使用赋值从中BigIntegerInt64创建值。

    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 转换为 a BigInteger

    BigInteger assignedFromDouble = (BigInteger) 179032.6541;
    Console.WriteLine(assignedFromDouble);
    BigInteger assignedFromDecimal = (BigInteger) 64312.65m;
    Console.WriteLine(assignedFromDecimal);
    // The example displays the following output:
    //   179032
    //   64312
    
    Dim assignedFromDouble As BigInteger = CType(179032.6541, BigInteger)
    Console.WriteLine(assignedFromDouble)   
    Dim assignedFromDecimal As BigInteger = CType(64312.65d, BigInteger)      
    Console.WriteLine(assignedFromDecimal)
    ' The example displays the following output:
    '   179032
    '   64312
    

这些方法使你能够实例化 BigInteger 其值仅位于现有数值类型之一范围内的对象。 可以实例化一个 BigInteger 对象,其值可以通过以下三种方式之一超过现有数值类型的范围:

  • 可以使用关键字 new ,并为构造函数提供任何大小的 BigInteger.BigInteger 字节数组。 例如:

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • 可以调用 ParseTryParse 方法将数字的字符串表示形式转换为 a BigInteger。 例如:

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • 可以在 Visual Basic) BigInteger 方法中调用一个static (Shared,该方法对数值表达式执行某些操作并返回计算BigInteger结果。 以下示例通过分块 UInt64.MaxValue 并将结果分配给 a BigInteger来执行此操作。

    BigInteger number = BigInteger.Pow(UInt64.MaxValue, 3);
    Console.WriteLine(number);
    // The example displays the following output:
    //    6277101735386680762814942322444851025767571854389858533375
    
    Dim number As BigInteger = BigInteger.Pow(UInt64.MaxValue, 3)
    Console.WriteLine(number)
    ' The example displays the following output:
      ' 6277101735386680762814942322444851025767571854389858533375
    

未初始化的值 BigIntegerZero

对 BigInteger 值执行操作

可以使用 BigInteger 实例,就像使用任何其他整型类型一样。 BigInteger 重载标准数值运算符,使你能够执行基本的数学运算,例如加法、减法、除法、乘法和一元负数。 还可以使用标准数值运算符将两 BigInteger 个值彼此进行比较。 与其他整型类型一样, BigInteger 还支持按位 AndOrXOr移和右移运算符。 对于不支持自定义运算符的语言,结构 BigInteger 还提供用于执行数学运算的等效方法。 Add其中包括、DivideMultiplyNegateSubtract几个其他项。

结构中的 BigInteger 许多成员直接对应于其他整型类型的成员。 此外, BigInteger 添加如下成员:

其中许多附加成员对应于类的成员,该成员 Math 提供使用基元数值类型的功能。

可变性和 BigInteger 结构

以下示例实例化一个 BigInteger 对象,然后将其值递增一个。

BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);
Dim number As BigInteger = BigInteger.Multiply(Int64.MaxValue, 3)
number += 1
Console.WriteLine(number)

虽然此示例似乎修改现有对象的值,但这不是这种情况。 BigInteger 对象是不可变的,这意味着在内部,公共语言运行时实际上会创建一个新 BigInteger 对象,并为其分配一个大于其上一个值的值。 然后,此新对象将返回到调用方。

备注

.NET 中的其他数值类型也是不可变的。 但是,由于 BigInteger 该类型没有上限或下限,因此其值可能会非常大,并且对性能产生可度量的影响。

尽管此过程对调用方是透明的,但它确实会产生性能损失。 在某些情况下,尤其是在对非常大 BigInteger 的值循环中执行重复操作时,性能损失可能很重要。 例如,在以下示例中,每次操作成功时,都会重复执行一次操作,并且每次操作成功时,都会递增一个 BigInteger 值。

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   number++;
}
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   number += 1
Next

在这种情况下,可以通过对变量执行所有中间赋值 Int32 来提高性能。 然后,当循环退出时,可以将变量的最终值分配给 BigInteger 对象。 下面的示例进行了这方面的演示。

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
int actualRepetitions = 0;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   actualRepetitions++;
}
number += actualRepetitions;
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
Dim actualRepetitions As Integer = 0
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   actualRepetitions += 1
Next
number += actualRepetitions

使用字节数组和十六进制字符串

如果将值转换为 BigInteger 字节数组,或者将字节数组转换为 BigInteger 值,则必须考虑字节的顺序。 结构 BigInteger 要求字节数组中的单个字节以小端顺序显示 (,即值下序字节之前) 。 可以通过调用ToByteArray该方法,然后将生成的字节数组传递给BigInteger(Byte[])构造函数来往返BigInteger值,如以下示例所示。

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[]) 为 -1,000,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”格式字符串时,为正值将前导零添加到返回的十六进制字符串。 这样就可以使用ToStringParse方法往返BigInteger值,如以下示例所示。

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

string negativeHex = negativeNumber.ToString("X");
string positiveHex = positiveNumber.ToString("X");

BigInteger negativeNumber2, positiveNumber2;
negativeNumber2 = BigInteger.Parse(negativeHex,
                                   NumberStyles.HexNumber);
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber);

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   negativeNumber, negativeHex, negativeNumber2);
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   positiveNumber, positiveHex, positiveNumber2);
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.
Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

Dim negativeHex As String = negativeNumber.ToString("X")
Dim positiveHex As string = positiveNumber.ToString("X")

Dim negativeNumber2, positiveNumber2 As BigInteger 
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber)
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber)

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2)                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2)                                         
' The example displays the following output:
'       Converted -1,000,000 to F0BDC0 back to -1,000,000.
'       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.

但是,通过调用ToString其他整型类型的方法或包含toBase参数的方法的重载ToString创建的十六进制字符串不指示从中派生十六进制字符串的值或源数据类型的符号。 成功实例化 BigInteger 此类字符串中的值需要一些额外的逻辑。 以下示例提供了一个可能的实现。

using System;
using System.Globalization;
using System.Numerics;

public struct HexValue
{
   public int Sign;
   public string Value;
}

public class Example
{
   public static void Main()
   {
      uint positiveNumber = 4039543321;
      int negativeNumber = -255423975;

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);

      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);

      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;

      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        positiveNumber, hexValue1.Value, positiveBigInt);

      hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        negativeNumber, hexValue2.Value, negativeBigInt);
   }
}
// The example displays the following output:
//       Converted 4039543321 to F0C68A19 and back to 4039543321.
//       Converted -255423975 to f0c68a19 and back to -255423975.
Imports System.Globalization
Imports System.Numerics

Public Structure HexValue
   Public Sign As Integer
   Public Value As String
End Structure
   
Module Example
   Public Sub Main()
      Dim positiveNumber As UInteger = 4039543321
      Dim negativeNumber As Integer = -255423975

      ' Convert the numbers to hex strings.
      Dim hexValue1, hexValue2 As HexValue
      hexValue1.Value = positiveNumber.ToString("X")
      hexValue1.Sign = Math.Sign(positiveNumber)
      
      hexValue2.Value = Convert.ToString(negativeNumber, 16)
      hexValue2.Sign = Math.Sign(negativeNumber)
      
      ' Round-trip the hexadecimal values to BigInteger values.
      Dim hexString As String
      Dim positiveBigInt, negativeBigInt As BigInteger
      
      hexString = CStr(IIf(hexValue1.Sign = 1, "0", "")) + hexValue1.Value
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt)

      hexString = CStr(IIf(hexValue2.Sign = 1, "0", "")) + hexValue2.Value
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt)

   End Sub
End Module
' The example displays the following output:
'       Converted 4039543321 to F0C68A19 and back to 4039543321.
'       Converted -255423975 to f0c68a19 and back to -255423975.

构造函数

BigInteger(Byte[])

使用字节数组中的值初始化 BigInteger 结构的新实例。

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)

使用 64 位无符号整数值初始化 BigInteger 结构的新实例。

属性

IsEven

指示当前 BigInteger 对象的值是否是偶数。

IsOne

指示当前 BigInteger 对象的值是否是 One

IsPowerOfTwo

指示当前 BigInteger 对象的值是否是 2 的幂。

IsZero

指示当前 BigInteger 对象的值是否是 Zero

MinusOne

获取一个表示数字负一 (-1) 的值。

One

获取一个表示数字一 (1) 的值。

Sign

获取一个数字,该数字指示当前 BigInteger 对象的符号(负、正或零)。

Zero

获取一个表示数字 0(零)的值。

方法

Abs(BigInteger)

获取 BigInteger 对象的绝对值。

Add(BigInteger, BigInteger)

将两个 BigInteger 值相加,并返回结果。

Clamp(BigInteger, BigInteger, BigInteger)

将值固定到非独占最小值和最大值。

Compare(BigInteger, BigInteger)

比较两个 BigInteger 值,并返回一个整数,该整数指示第一个值是小于、等于还是大于第二个值。

CompareTo(BigInteger)

将此实例与另一个 BigInteger 进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。

CompareTo(Int64)

将此实例与 64 位带符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位带符号整数的值。

CompareTo(Object)

将此实例与指定对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。

CompareTo(UInt64)

将此实例与 64 位无符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位无符号整数的值。

CopySign(BigInteger, BigInteger)

将值的符号复制到另一个值的符号。

Divide(BigInteger, BigInteger)

用另一个值除 BigInteger 值并返回结果。

DivRem(BigInteger, BigInteger)

计算两个值的商和余数。

DivRem(BigInteger, BigInteger, BigInteger)

用另一个值除一个 BigInteger 值,返回结果,并在输出参数中返回余数。

Equals(BigInteger)

返回一个值,该值指示当前实例与指定的 BigInteger 对象是否具有相同的值。

Equals(Int64)

返回一个值,该值指示当前实例与 64 位带符号整数是否具有相同的值。

Equals(Object)

返回一个值,该值指示当前实例与指定的对象是否具有相同的值。

Equals(UInt64)

返回一个值,该值指示当前实例与 64 位无符号整数是否具有相同的值。

GetBitLength()

获取当前实例的最短两个补码表示形式(不带符号位)所需的位数。

GetByteCount(Boolean)

获取将由 ToByteArray(Boolean, Boolean)TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) 输出的字节数。

GetHashCode()

返回当前 BigInteger 对象的哈希代码。

GreatestCommonDivisor(BigInteger, BigInteger)

查找两个 BigInteger 值的最大公约数。

IsEvenInteger(BigInteger)

确定值是否表示偶数。

IsNegative(BigInteger)

确定值是否为负值。

IsOddInteger(BigInteger)

确定值是否表示奇数整数。

IsPositive(BigInteger)

确定值是否为正值。

IsPow2(BigInteger)

确定值是否为 2 的幂。

LeadingZeroCount(BigInteger)

计算值中的前导零数。

Log(BigInteger)

返回指定数字的自然对数(底为 e)。

Log(BigInteger, Double)

返回指定数字在使用指定底时的对数。

Log10(BigInteger)

返回指定数字以 10 为底的对数。

Log2(BigInteger)

计算值的 log2。

Max(BigInteger, BigInteger)

返回两个 BigInteger 值中的较大者。

MaxMagnitude(BigInteger, BigInteger)

将两个值与计算进行比较,该值更大。

Min(BigInteger, BigInteger)

返回两个 BigInteger 值中的较小者。

MinMagnitude(BigInteger, BigInteger)

比较两个值,计算值越少。

ModPow(BigInteger, BigInteger, BigInteger)

对以某个数为底、以另一个数为指数的幂执行模数除法。

Multiply(BigInteger, BigInteger)

返回两个 BigInteger 值的乘积。

Negate(BigInteger)

对指定的 BigInteger 值求反。

Parse(ReadOnlySpan<Char>, IFormatProvider)

将字符范围分析为值。

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

以指定的样式将包含在指定的字符只读范围内的数字表示形式转换为其 BigInteger 等效项。

Parse(String)

将数字的字符串表示形式转换为它的等效 BigInteger 表示形式。

Parse(String, IFormatProvider)

将指定的区域性特定格式的数字字符串表示形式转换为它的等效 BigInteger

Parse(String, NumberStyles)

将指定样式的数字的字符串表示形式转换为它的等效 BigInteger

Parse(String, NumberStyles, IFormatProvider)

将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 BigInteger

PopCount(BigInteger)

计算值中设置的位数。

Pow(BigInteger, Int32)

求以 BigInteger 值为底、以指定的值为指数的幂。

Remainder(BigInteger, BigInteger)

对两个 BigInteger 值执行整除并返回余数。

RotateLeft(BigInteger, Int32)

将一个值左移一个给定的量。

RotateRight(BigInteger, Int32)

按给定量向右旋转值。

Subtract(BigInteger, BigInteger)

从另一个值中减去一个 BigInteger 值并返回结果。

ToByteArray()

BigInteger 值转换为字节数组。

ToByteArray(Boolean, Boolean)

使用尽可能少的字节数返回此 BigInteger 的值作为字节数组。 如果值为零,则返回一个字节(其元素为 0x00)的数组。

ToString()

将当前 BigInteger 对象的数值转换为其等效字符串表示形式。

ToString(IFormatProvider)

使用指定的区域性特定格式设置信息将当前 BigInteger 对象的数值转换为它的等效字符串表示形式。

ToString(String)

使用指定的格式将当前 BigInteger 对象的数值转换为它的等效字符串表示形式。

ToString(String, IFormatProvider)

使用指定的格式和区域性特定格式信息将当前 BigInteger 对象的数值转换为它的等效字符串表示形式。

TrailingZeroCount(BigInteger)

计算值中的尾随零数。

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

将此大整数实例格式设置到一个字符范围内。

TryParse(ReadOnlySpan<Char>, BigInteger)

尝试将指定的字符只读范围中包含的数字的表示形式转换为其 BigInteger 等效项,并返回一个指示转换是否成功的值。

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

尝试将字符范围分析为值。

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

尝试将数字的字符串表示形式转换为它的等效 BigInteger,并返回一个指示转换是否成功的值。

TryParse(String, BigInteger)

尝试将数字的字符串表示形式转换为它的等效 BigInteger,并返回一个指示转换是否成功的值。

TryParse(String, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger)

尝试将指定样式和区域性特定格式的数字的字符串表示形式转换为其 BigInteger 等效项,并返回一个指示转换是否成功的值。

TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

使用尽可能少的字节数将此 BigInteger 的值复制为小端二进制补码字节。 如果值为零,则输入其元素为 0x00 的字节。

运算符

Addition(BigInteger, BigInteger)

将两个指定的 BigInteger 对象的值相加。

BitwiseAnd(BigInteger, BigInteger)

对两个 BigInteger 值执行按位 And 运算。

BitwiseOr(BigInteger, BigInteger)

对两个 BigInteger 值执行按位 Or 运算。

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)

对两个 BigInteger 值执行按位异 Or (XOr) 运算。

Explicit(BigInteger to Byte)

定义从 BigInteger 对象到无符号字节值的显式转换。

Explicit(BigInteger to Char)

将大整数显式转换为 Char 值。

Explicit(BigInteger to Decimal)

定义从 BigInteger 对象到 Decimal 值的显式转换。

Explicit(BigInteger to Double)

定义从 BigInteger 对象到 Double 值的显式转换。

Explicit(BigInteger to Half)

显式将大整数转换为 Half 值。

Explicit(BigInteger to Int128)

显式将大整数转换为 Int128 值。

Explicit(BigInteger to Int16)

定义从 BigInteger 对象到 16 位带符号整数值的显式转换。

Explicit(BigInteger to Int32)

定义从 BigInteger 对象到 32 位带符号整数值的显式转换。

Explicit(BigInteger to Int64)

定义从 BigInteger 对象到 64 位带符号整数值的显式转换。

Explicit(BigInteger to IntPtr)

显式将大整数转换为 IntPtr 值。

Explicit(BigInteger to SByte)

定义从 BigInteger 对象到 8 位带符号值的显式转换。

此 API 不兼容 CLS。 符合的替代方法是 Int16

Explicit(BigInteger to Single)

定义从 BigInteger 对象到单精度浮点值的显式转换。

Explicit(BigInteger to UInt128)

显式将大整数转换为 UInt128 值。

Explicit(BigInteger to UInt16)

定义从 BigInteger 对象到 16 位无符号整数值的显式转换。

此 API 不兼容 CLS。 符合的替代方法是 Int32

Explicit(BigInteger to UInt32)

定义从 BigInteger 对象到 32 位无符号整数值的显式转换。

此 API 不兼容 CLS。 符合的替代方法是 Int64

Explicit(BigInteger to UInt64)

定义从 BigInteger 对象到 64 位无符号整数值的显式转换。

此 API 不兼容 CLS。 符合的替代方法是 Double

Explicit(BigInteger to UIntPtr)

显式将大整数转换为 UIntPtr 值。

Explicit(Complex to BigInteger)

显式将值 Complex 转换为大整数。

Explicit(Decimal to BigInteger)

定义从 Decimal 对象到 BigInteger 值的显式转换。

Explicit(Double to BigInteger)

定义从 Double 值到 BigInteger 值的显式转换。

Explicit(Half to BigInteger)

将值 Half 显式转换为大整数。

Explicit(Single to BigInteger)

定义从 Single 值到 BigInteger 值的显式转换。

GreaterThan(BigInteger, BigInteger)

返回一个值,该值指示 BigInteger 值是否大于另一个 BigInteger 值。

GreaterThan(BigInteger, Int64)

返回一个值,该值指示 BigInteger 是否大于 64 位带符号整数值。

GreaterThan(BigInteger, UInt64)

返回一个值,该值指示 BigInteger 值是否大于 64 位无符号整数。

GreaterThan(Int64, BigInteger)

返回一个值,该值指示 64 位带符号整数是否大于 BigInteger 值。

GreaterThan(UInt64, BigInteger)

返回一个值,该值指示 BigInteger 值是否大于 64 位无符号整数。

GreaterThanOrEqual(BigInteger, BigInteger)

返回一个值,该值指示 BigInteger 值是否大于等于另一个 BigInteger 值。

GreaterThanOrEqual(BigInteger, Int64)

返回一个值,该值指示 BigInteger 值是否大于等于 64 位带符号整数值。

GreaterThanOrEqual(BigInteger, UInt64)

返回一个值,该值指示 BigInteger 值是否大于等于 64 位无符号整数值。

GreaterThanOrEqual(Int64, BigInteger)

返回一个值,该值指示 64 位带符号整数是否大于等于 BigInteger 值。

GreaterThanOrEqual(UInt64, BigInteger)

返回一个值,该值指示 64 位无符号整数是否大于等于 BigInteger 值。

Implicit(Byte to BigInteger)

定义从无符号字节到 BigInteger 值的隐式转换。

Implicit(Char to BigInteger)

隐式将值 Char 转换为大整数。

Implicit(Int128 to BigInteger)

隐式将值 Int128 转换为大整数。

Implicit(Int16 to BigInteger)

定义从 16 位带符号整数到 BigInteger 值的隐式转换。

Implicit(Int32 to BigInteger)

定义从 32 位带符号整数到 BigInteger 值的隐式转换。

Implicit(Int64 to BigInteger)

定义从 64 位带符号整数到 BigInteger 值的隐式转换。

Implicit(IntPtr to BigInteger)

隐式将值 IntPtr 转换为大整数。

Implicit(SByte to BigInteger)

定义从 8 位带符号整数到 BigInteger 值的隐式转换。

此 API 不兼容 CLS。 符合的替代方法是 BigInteger(Int32)

Implicit(UInt128 to BigInteger)

隐式将值 UInt128 转换为大整数。

Implicit(UInt16 to BigInteger)

定义从 16 位无符号整数到 BigInteger 值的隐式转换。

此 API 不兼容 CLS。 符合的替代方法是 Implicit(Int32 to BigInteger)

Implicit(UInt32 to BigInteger)

定义从 32 位无符号整数到 BigInteger 值的隐式转换。

此 API 不兼容 CLS。 符合的替代方法是 Implicit(Int64 to BigInteger)

Implicit(UInt64 to BigInteger)

定义从 64 位无符号整数到 BigInteger 值的隐式转换。

此 API 不兼容 CLS。 符合的替代方法是 Double

Implicit(UIntPtr to BigInteger)

隐式将值 UIntPtr 转换为大整数。

Increment(BigInteger)

BigInteger 值加 1。

Inequality(BigInteger, BigInteger)

返回一个值,该值指示两个 BigInteger 对象是否具有不同的值。

Inequality(BigInteger, Int64)

返回一个值,该值指示 BigInteger 值与 64 位带符号整数是否不相等。

Inequality(BigInteger, UInt64)

返回一个值,该值指示 BigInteger 值与 64 位无符号整数是否不相等。

Inequality(Int64, BigInteger)

返回一个值,该值指示 64 位带符号整数与 BigInteger 值是否不相等。

Inequality(UInt64, BigInteger)

返回一个值,该值指示 64 位无符号整数与 BigInteger 值是否不相等。

LeftShift(BigInteger, Int32)

BigInteger 值向左移动指定的位数。

LessThan(BigInteger, BigInteger)

返回一个值,该值指示 BigInteger 值是否小于另一个 BigInteger 值。

LessThan(BigInteger, Int64)

返回一个值,该值指示 BigInteger 值是否小于 64 位带符号整数。

LessThan(BigInteger, UInt64)

返回一个值,该值指示 BigInteger 值是否小于 64 位无符号整数。

LessThan(Int64, BigInteger)

返回一个值,该值指示 64 位带符号整数是否小于 BigInteger 值。

LessThan(UInt64, BigInteger)

返回一个值,该值指示 64 位无符号整数是否小于 BigInteger 值。

LessThanOrEqual(BigInteger, BigInteger)

返回一个值,该值指示 BigInteger 值是否小于等于另一个 BigInteger 值。

LessThanOrEqual(BigInteger, Int64)

返回一个值,该值指示 BigInteger 值是否小于等于 64 位带符号整数。

LessThanOrEqual(BigInteger, UInt64)

返回一个值,该值指示 BigInteger 值是否小于等于 64 位无符号整数。

LessThanOrEqual(Int64, BigInteger)

返回一个值,该值指示 64 位带符号整数是否小于等于 BigInteger 值。

LessThanOrEqual(UInt64, BigInteger)

返回一个值,该值指示 64 位无符号整数是否小于等于 BigInteger 值。

Modulus(BigInteger, BigInteger)

返回两个指定 BigInteger 值相除所得的余数。

Multiply(BigInteger, BigInteger)

两个指定的 BigInteger 值相乘。

OnesComplement(BigInteger)

返回 BigInteger 值的按位二进制反码。

RightShift(BigInteger, Int32)

BigInteger 值向右移动指定的位数。

Subtraction(BigInteger, BigInteger)

从另一个 BigInteger 值中减去 BigInteger 值。

UnaryNegation(BigInteger)

对指定的 BigInteger 值求反。

UnaryPlus(BigInteger)

返回 BigInteger 操作数的值。 (操作数的符号不变。)

UnsignedRightShift(BigInteger, Int32)

按给定金额右移值。

显式接口实现

IBinaryInteger<BigInteger>.GetByteCount()

获取将作为其一部分 TryWriteLittleEndian(Span<Byte>, Int32)写入的字节数。

IBinaryInteger<BigInteger>.GetShortestBitLength()

获取当前值的最短两个补补表示形式的长度(以位为单位)。

IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)

尝试将当前值(采用 big-endian 格式)写入给定范围。

IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)

尝试将当前值(以小端格式)写入给定范围。

IComparable.CompareTo(Object)

将此实例与指定对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。

适用于