BigInteger Struktur

Definition

Namespace:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.

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

Vererbung

Object

ValueType

BigInteger

Implementiert

IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TSelf> 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> 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>

Hinweise

Der BigInteger Typ ist ein unveränderlicher Typ, der eine beliebig große ganze Zahl darstellt, deren Wert theoretisch keine Ober- oder Untergrenze aufweist. Die Member des BigInteger Typs sind eng mit denen anderer integraler Typen (die ByteTypen , , Int32Int16, Int64, UInt32SByteUInt16, und UInt64 ) parallel. Dieser Typ unterscheidet sich von den anderen integralen Typen im .NET Framework, die über einen Bereich verfügen, der durch ihre MinValue Eigenschaften und MaxValue angegeben ist.

Hinweis

Da der BigInteger Typ unveränderlich ist (siehe Veränderlichkeit und bigInteger-Struktur), und da er keine Ober- oder Untergrenzen aufweist, kann für jeden Vorgang, OutOfMemoryException der dazu führt, dass ein BigInteger Wert zu groß wird, ausgelöst werden.

Instanziieren eines BigInteger-Objekts

Sie können ein BigInteger Objekt auf verschiedene Arten instanziieren:

• Sie können die new Schlüsselwort (keyword) verwenden und einen beliebigen Integral- oder Gleitkommawert als Parameter für den BigInteger Konstruktor angeben. (Gleitkommawerte werden abgeschnitten, bevor sie dem BigIntegerzugewiesen werden.) Im folgenden Beispiel wird veranschaulicht, wie Sie die new Schlüsselwort (keyword) verwenden, um Werte zu instanziierenBigInteger.

  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
  

• Sie können eine BigInteger Variable deklarieren und ihr wie jeder numerische Typ einen Wert zuweisen, solange dieser Wert ein integraler Typ ist. Im folgenden Beispiel wird die Zuweisung verwendet, um einen BigInteger Wert aus einem Int64zu erstellen.

  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
  

• Sie können einem BigInteger Objekt einen Dezimal- oder Gleitkommawert zuweisen, wenn Sie den Wert zuerst umwandeln oder konvertieren. Im folgenden Beispiel wird explizit (in C#) umgewandelt oder konvertiert (in Visual Basic) ein Double - und ein Decimal -Wert in einen 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
  

Mit diesen Methoden können Sie ein BigInteger Objekt instanziieren, dessen Wert nur im Bereich eines der vorhandenen numerischen Typen liegt. Sie können ein BigInteger Objekt instanziieren, dessen Wert den Bereich der vorhandenen numerischen Typen auf eine von drei Arten überschreiten kann:

• Sie können die new Schlüsselwort (keyword) verwenden und dem BigInteger.BigInteger Konstruktor ein Bytearray beliebiger Größe bereitstellen. Beispiel:

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

• Sie können die Parse -Methode oder TryParse aufrufen, um die Zeichenfolgendarstellung einer Zahl in eine BigIntegerzu konvertieren. Beispiel:

  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
  

• Sie können eine static Methode (Shared in Visual Basic) BigInteger aufrufen, die einen Vorgang für einen numerischen Ausdruck ausführt und ein berechnetes BigInteger Ergebnis zurückgibt. Im folgenden Beispiel erfolgt dies durch Cubing UInt64.MaxValue und Zuweisen des Ergebnisses zu einem 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
  

Der nicht initialisierte Wert von ist BigIntegerZero.

Ausführen von Vorgängen für BigInteger-Werte

Sie können eine BigInteger instance wie jeden anderen integralen Typ verwenden. BigInteger überlädt die numerischen Standardoperatoren, damit Sie grundlegende mathematische Operationen wie Addition, Subtraktion, Division, Multiplikation und unäre Negation ausführen können. Sie können auch die numerischen Standardoperatoren verwenden, um zwei BigInteger Werte miteinander zu vergleichen. Wie die anderen integralen Typen BigInteger unterstützt auch die operatoren bitweise And, Or, XOr, linksverschiebung und rechts. Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, stellt die BigInteger -Struktur auch gleichwertige Methoden zum Ausführen mathematischer Operationen bereit. Dazu gehören Add, Divide, Multiply, Negate, Subtract, und mehrere andere.

Viele Member der BigInteger -Struktur entsprechen direkt den Membern der anderen integralen Typen. Darüber hinaus BigInteger werden Elemente wie die folgenden hinzugefügt:

• Sign, der einen Wert zurückgibt, der das Vorzeichen eines BigInteger Werts angibt.

• Abs, der den absoluten Wert eines BigInteger Werts zurückgibt.

• DivRem, der sowohl den Quotienten als auch den Rest eines Divisionsvorgangs zurückgibt.

• GreatestCommonDivisor, der den größten gemeinsamen Divisor von zwei BigInteger Werten zurückgibt.

Viele dieser zusätzlichen Member entsprechen den Membern der Math -Klasse, die die Funktionalität zum Arbeiten mit den primitiven numerischen Typen bereitstellt.

Änderbarkeit und die BigInteger-Struktur

Im folgenden Beispiel wird ein BigInteger -Objekt instanziiert und dann dessen Wert um eins erhöht.

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)

Obwohl in diesem Beispiel der Wert des vorhandenen Objekts zu ändern scheint, ist dies nicht der Fall. BigInteger -Objekte sind unveränderlich, was bedeutet, dass die Common Language Runtime intern tatsächlich ein neues BigInteger Objekt erstellt und ihm einen Wert zuweist, der größer als sein vorheriger Wert ist. Dieses neue Objekt wird dann an den Aufrufer zurückgegeben.

Hinweis

Die anderen numerischen Typen in .NET sind ebenfalls unveränderlich. Da der BigInteger Typ jedoch keine Ober- oder Untergrenzen aufweist, können seine Werte extrem groß werden und einen messbaren Einfluss auf die Leistung haben.

Obwohl dieser Prozess für den Aufrufer transparent ist, kommt es zu Leistungseinbußen. In einigen Fällen, insbesondere wenn wiederholte Vorgänge in einer Schleife mit sehr großen BigInteger Werten ausgeführt werden, kann diese Leistungseinbuße erheblich sein. Im folgenden Beispiel wird ein Vorgang beispielsweise bis zu einer Million Mal wiederholt ausgeführt, und ein BigInteger Wert wird bei jedem erfolgreichen Vorgang um eins erhöht.

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

In einem solchen Fall können Sie die Leistung verbessern, indem Sie alle zwischengeschalteten Zuweisungen zu einer Int32 Variablen ausführen. Der Endwert der Variablen kann dann dem BigInteger -Objekt zugewiesen werden, wenn die Schleife beendet wird. Dies wird im folgenden Beispiel veranschaulicht.

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

Arbeiten mit Bytearrays und Hexadezimalzeichenfolgen

Wenn Sie Werte in Bytearrays konvertieren BigInteger oder Bytearrays in BigInteger Werte konvertieren, müssen Sie die Reihenfolge der Bytes berücksichtigen. Die BigInteger -Struktur erwartet, dass die einzelnen Bytes in einem Bytearray in little-endian-Reihenfolge angezeigt werden (d. a. die bytes niedrigeren Reihenfolge des Werts gehen den Bytes höherer Ordnung voraus). Sie können einen Roundtrip für einen BigInteger Wert ausführen, indem Sie die ToByteArray -Methode aufrufen und dann das resultierende Bytearray an den BigInteger(Byte[]) Konstruktor übergeben, wie im folgenden Beispiel gezeigt.

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

Um einen BigInteger Wert aus einem Bytearray zu instanziieren, das einen Wert eines anderen integralen Typs darstellt, können Sie den integralen Wert an die BitConverter.GetBytes -Methode übergeben und dann das resultierende Bytearray an den BigInteger(Byte[]) Konstruktor übergeben. Im folgenden Beispiel wird ein BigInteger Wert aus einem Bytearray instanziiert, der einen Int16 Wert darstellt.

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

Die BigInteger -Struktur geht davon aus, dass negative Werte mithilfe der Komplementdarstellung von zwei gespeichert werden. Da die BigInteger Struktur einen numerischen Wert ohne feste Länge darstellt, interpretiert der BigInteger(Byte[]) Konstruktor immer das bedeutendste Bit des letzten Byte im Array als Vorzeichenbit. Um zu verhindern, dass der BigInteger(Byte[]) Konstruktor die Komplementdarstellung eines negativen Werts mit der Vorzeichen- und Größendarstellung eines positiven Werts verwechselt, sollten positive Werte, bei denen das bedeutendste Bit des letzten Byte im Bytearray normalerweise festgelegt wird, ein zusätzliches Byte enthalten, dessen Wert 0 ist. Beispielsweise ist 0xC0 0xBD 0xF0 0xFF die Hexadezimaldarstellung von -1.000.000 oder 4.293.967.296. Da das wichtigste Bit des letzten Bytes in diesem Array aktiviert ist, wird der Wert des Bytearrays vom BigInteger(Byte[]) Konstruktor als -1.000.000 interpretiert. Um ein BigInteger zu instanziieren, dessen Wert positiv ist, muss ein Bytearray, dessen Elemente 0xC0 0xBD 0xF0 0xFF 0x00 sind, an den Konstruktor übergeben werden. Dies wird anhand des folgenden Beispiels veranschaulicht.

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

Bytearrays, die von der ToByteArray -Methode aus positiven Werten erstellt werden, enthalten dieses zusätzliche Null-Wert-Byte. Daher kann die BigInteger -Struktur erfolgreich Roundtripwerte durchführen, indem sie bytearrays zugewiesen und dann wie im folgenden Beispiel dargestellt aus bytearrays wiederherstellen.

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

Möglicherweise müssen Sie dieses zusätzliche Nullwert-Byte jedoch Bytearrays hinzufügen, die dynamisch vom Entwickler erstellt werden oder die von Methoden zurückgegeben werden, die ganze Zahlen ohne Vorzeichen in Bytearrays konvertieren (z BitConverter.GetBytes(UInt16). B. , BitConverter.GetBytes(UInt32)und BitConverter.GetBytes(UInt64)).

Beim Analysieren einer hexadezimalen Zeichenfolge gehen die BigInteger.Parse(String, NumberStyles) Methoden und BigInteger.Parse(String, NumberStyles, IFormatProvider) davon aus, dass der Wert mithilfe der Komplementdarstellung von zwei dargestellt wird, wenn das wichtigste Bit des ersten Bytebytes festgelegt ist oder wenn die erste Hexadezimalziffer der Zeichenfolge die unteren vier Bits eines Bytewerts darstellt. Beispielsweise stellen sowohl "FF01" als auch "F01" den Dezimalwert -255 dar. Um positive von negativen Werten zu unterscheiden, sollten positive Werte eine führende Null enthalten. Die relevanten Überladungen der ToString -Methode fügen der zurückgegebenen Hexadezimalzeichenfolge für positive Werte eine führende Null hinzu, wenn sie die Formatzeichenfolge "X" übergeben. Dadurch können Roundtripwerte BigInteger mithilfe der ToString Methoden und Parse verwendet werden, wie im folgenden Beispiel gezeigt.

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.

Die hexadezimalen Zeichenfolgen, die durch Aufrufen der ToString Methoden der anderen integralen Typen erstellt werden, oder die Überladungen der Methode, die ToString einen toBase -Parameter enthalten, geben jedoch nicht das Vorzeichen des Werts oder den Quelldatentyp an, von dem die hexadezimale Zeichenfolge abgeleitet wurde. Das erfolgreiche Instanziieren eines Werts BigInteger aus einer solchen Zeichenfolge erfordert zusätzliche Logik. Im folgenden Beispiel wird eine mögliche Implementierung bereitgestellt.

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.

Konstruktoren

BigInteger(Byte[])	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einem Bytearray.
BigInteger(Decimal)	Initialisiert eine neue Instanz der BigInteger-Struktur mit einem Decimal-Wert.
BigInteger(Double)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit doppelter Genauigkeit.
BigInteger(Int32)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl mit Vorzeichen.
BigInteger(Int64)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 64-Bit-Ganzzahl mit Vorzeichen.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einer schreibgeschützten Spanne von Bytes und zeigt optional die Signaturcodierung und die Endianness-Bytereihenfolge an.
BigInteger(Single)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit einfacher Genauigkeit.
BigInteger(UInt32)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl ohne Vorzeichen.
BigInteger(UInt64)	Initialisiert eine neue Instanz der BigInteger-Struktur mit dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.

Eigenschaften

IsEven	Gibt an, ob der Wert des aktuellen BigInteger-Objekts eine gerade Zahl ist.
IsOne	Gibt an, ob der Wert des aktuellen BigInteger-Objekts One ist.
IsPowerOfTwo	Gibt an, ob der Wert des aktuellen BigInteger-Objekts eine Potenz von Zwei ist.
IsZero	Gibt an, ob der Wert des aktuellen BigInteger-Objekts Zero ist.
MinusOne	Ruft einen Wert ab, der die Zahl -1 darstellt.
One	Ruft einen Wert ab, der die Zahl 1 darstellt.
Sign	Ruft eine Zahl ab, die das Vorzeichen (negativ, positiv, oder 0 (null)) des aktuellen BigInteger-Objekts angibt.
Zero	Ruft einen Wert ab, der die Zahl null (0) darstellt.

Methoden

Abs(BigInteger)	Ruft den absoluten Wert eines BigInteger-Objekts ab.
Add(BigInteger, BigInteger)	Addiert zwei BigInteger-Werte und gibt das Ergebnis zurück.
Clamp(BigInteger, BigInteger, BigInteger)	Klemmt einen Wert auf einen inklusiven Minimal- und Höchstwert.
Compare(BigInteger, BigInteger)	Vergleicht zwei BigInteger-Werte und gibt eine ganze Zahl zurück, die angibt, ob der erste Wert kleiner oder größer als der zweite Wert oder gleich dem zweiten Wert ist.
CompareTo(BigInteger)	Vergleicht diese Instanz mit einem zweiten BigInteger und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
CompareTo(Int64)	Vergleicht diese Instanz mit einer 64-Bit-Ganzzahl mit Vorzeichen und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der 64-Bit-Ganzzahl mit Vorzeichen ist oder mit diesem übereinstimmt.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
CompareTo(UInt64)	Vergleicht diese Instanz mit einer 64-Bit-Ganzzahl ohne Vorzeichen und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der 64-Bit-Ganzzahl ohne Vorzeichen ist oder mit diesem übereinstimmt.
CopySign(BigInteger, BigInteger)	Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
Divide(BigInteger, BigInteger)	Dividiert einen BigInteger-Wert durch einen anderen und gibt das Ergebnis zurück.
DivRem(BigInteger, BigInteger)	Berechnet den Quotienten und den Rest von zwei Werten.
DivRem(BigInteger, BigInteger, BigInteger)	Dividiert einen BigInteger-Wert durch einen anderen, gibt das Ergebnis zurück und gibt den Rest in einem Ausgabeparameter zurück.
Equals(BigInteger)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger-Objekt über den gleichen Wert verfügen.
Equals(Int64)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl mit Vorzeichen über den gleichen Wert verfügen.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen.
Equals(UInt64)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl ohne Vorzeichen über den gleichen Wert verfügen.
GetBitLength()	Ruft die Anzahl der Bits ab, die für die kürzeste Zweierkomplementdarstellung der aktuellen Instanz ohne Vorzeichenbit erforderlich sind.
GetByteCount(Boolean)	Ruft die Anzahl der Bytes ab, die von ToByteArray(Boolean, Boolean) und TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) ausgegeben werden.
GetHashCode()	Gibt den Hashcode für das aktuelle BigInteger-Objekt zurück.
GreatestCommonDivisor(BigInteger, BigInteger)	Sucht den größten gemeinsamen Divisor von zwei BigInteger-Werten.
IsEvenInteger(BigInteger)	Bestimmt, ob ein Wert eine gerade ganzzahlige Zahl darstellt.
IsNegative(BigInteger)	Bestimmt, ob ein Wert negativ ist.
IsOddInteger(BigInteger)	Bestimmt, ob ein Wert eine ungerade ganzzahlige Zahl darstellt.
IsPositive(BigInteger)	Bestimmt, ob ein Wert positiv ist.
IsPow2(BigInteger)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
LeadingZeroCount(BigInteger)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log(BigInteger)	Gibt den natürlichen Logarithmus (zur Basis e) der angegebenen Zahl zurück.
Log(BigInteger, Double)	Gibt den Logarithmus einer angegebenen Zahl bezüglich einer angegebenen Basis zurück.
Log10(BigInteger)	Gibt den Logarithmus einer angegebenen Zahl zur Basis 10 zurück.
Log2(BigInteger)	Berechnet das Protokoll2 eines Werts.
Max(BigInteger, BigInteger)	Gibt den größeren der beiden BigInteger-Werte zurück.
MaxMagnitude(BigInteger, BigInteger)	Vergleicht zwei Werte mit einem höheren Computewert.
Min(BigInteger, BigInteger)	Gibt den kleineren der beiden BigInteger-Werte zurück.
MinMagnitude(BigInteger, BigInteger)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
ModPow(BigInteger, BigInteger, BigInteger)	Führt eine Modulodivision für eine zur Potenz einer anderen Zahl erhobene Zahl aus.
Multiply(BigInteger, BigInteger)	Gibt das Produkt der beiden BigInteger-Werte zurück.
Negate(BigInteger)	Negiert einen angegebenen BigInteger-Wert.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die-Darstellung einer Zahl, die in der angegebenen schreibgeschützten Spanne von Zeichen enthalten ist, in einem angegebenen Stil in die jeweilige BigInteger-Entsprechung.
Parse(String)	Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende BigInteger.
PopCount(BigInteger)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
Pow(BigInteger, Int32)	Potenziert einen BigInteger-Wert mit einem angegebenen Wert.
Remainder(BigInteger, BigInteger)	Führt die Ganzzahldivision von zwei BigInteger-Werten aus und gibt den Rest zurück.
RotateLeft(BigInteger, Int32)	Rotiert einen Wert, der um einen bestimmten Betrag verlassen wird.
RotateRight(BigInteger, Int32)	Rotiert einen Wert nach rechts um einen bestimmten Betrag.
Subtract(BigInteger, BigInteger)	Subtrahiert einen BigInteger-Wert von einem anderen und gibt das Ergebnis zurück.
ToByteArray()	Konvertiert einen BigInteger-Wert in ein Bytearray.
ToByteArray(Boolean, Boolean)	Liefert den Wert dieses BigInteger als Bytearray mit der kleinstmöglichen Anzahl von Bytes. Wenn der Wert Null (0) ist, wird ein Array von einem Byte zurückgegeben, dessen Element 0x00 ist.
ToString()	Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats und der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
TrailingZeroCount(BigInteger)	Berechnet die Anzahl der nachfolgenden Nullen in einem Wert.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Formatiert diese BigInteger-Instanz in eine Spanne von Zeichen.
TryParse(ReadOnlySpan<Char>, BigInteger)	Versucht, die Darstellung einer Zahl, die in der angegebenen schreibgeschützten Zeichenspanne enthalten ist, in ihre Entsprechung BigInteger zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
TryParse(String, BigInteger)	Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
TryParse(String, IFormatProvider, BigInteger)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in das entsprechende BigInteger und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Kopiert den Wert dieses BigInteger als Little-Endian-Zweierkomplementbytes mit der geringstmöglichen Anzahl von Bytes. Wenn der Wert Null (0) ist, wird nur ein Byte ausgegeben, dessen Element 0x00 ist.

Operatoren

Addition(BigInteger, BigInteger)	Addiert die Werte von zwei angegebenen BigInteger-Objekten.
BitwiseAnd(BigInteger, BigInteger)	Führt eine bitweise And-Operation für zwei BigInteger-Werte aus.
BitwiseOr(BigInteger, BigInteger)	Führt eine bitweise Or-Operation für zwei BigInteger-Werte aus.
Decrement(BigInteger)	Dekrementiert einen BigInteger-Wert um 1.
Division(BigInteger, BigInteger)	Dividiert einen angegebenen BigInteger-Wert durch einen anderen angegebenen BigInteger-Wert mit einer Ganzzahldivision.
Equality(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob die Werte von zwei BigInteger-Objekten gleich sind.
Equality(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und der Wert einer langen ganzen Zahl mit Vorzeichen gleich sind.
Equality(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und der Wert einer langen ganzen Zahl ohne Vorzeichen gleich sind.
Equality(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob der Wert einer langen ganzen Zahl mit Vorzeichen und ein BigInteger-Wert gleich sind.
Equality(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob der Wert einer langen ganzen Zahl ohne Vorzeichen und ein BigInteger-Wert gleich sind.
ExclusiveOr(BigInteger, BigInteger)	Führt eine bitweise exklusive Or-Operation (XOr-Operation) für zwei BigInteger-Werte aus.
Explicit(BigInteger to Byte)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Bytewert ohne Vorzeichen.
Explicit(BigInteger to Char)	Konvertiert eine große ganze Zahl explizit in einen Char Wert.
Explicit(BigInteger to Decimal)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Decimal-Wert.
Explicit(BigInteger to Double)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Double-Wert.
Explicit(BigInteger to Half)	Konvertiert eine große ganze Zahl explizit in einen Half Wert.
Explicit(BigInteger to Int128)	Konvertiert eine große ganze Zahl explizit in einen Int128 Wert.
Explicit(BigInteger to Int16)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl mit Vorzeichen.
Explicit(BigInteger to Int32)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl mit Vorzeichen.
Explicit(BigInteger to Int64)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl mit Vorzeichen.
Explicit(BigInteger to IntPtr)	Konvertiert eine große ganze Zahl explizit in einen IntPtr Wert.
Explicit(BigInteger to SByte)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen 8-Bit-Wert mit Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int16.
Explicit(BigInteger to Single)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Gleitkommawert mit einfacher Genauigkeit.
Explicit(BigInteger to UInt128)	Konvertiert eine große ganze Zahl explizit in einen UInt128 Wert.
Explicit(BigInteger to UInt16)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl ohne Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int32.
Explicit(BigInteger to UInt32)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl ohne Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int64.
Explicit(BigInteger to UInt64)	Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl ohne Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Double.
Explicit(BigInteger to UIntPtr)	Konvertiert eine große ganze Zahl explizit in einen UIntPtr Wert.
Explicit(Complex to BigInteger)	Konvertiert einen Complex Wert explizit in eine große ganze Zahl.
Explicit(Decimal to BigInteger)	Definiert eine explizite Konvertierung eines Decimal-Objekts in einen BigInteger-Wert.
Explicit(Double to BigInteger)	Definiert eine explizite Konvertierung eines Double-Werts in einen BigInteger-Wert.
Explicit(Half to BigInteger)	Konvertiert einen Half Wert explizit in eine große ganze Zahl.
Explicit(Single to BigInteger)	Definiert eine explizite Konvertierung eines Single-Werts in einen BigInteger-Wert.
GreaterThan(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als ein anderer BigInteger-Wert ist.
GreaterThan(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger größer als der Wert einer 64-Bit-Ganzzahl mit Vorzeichen ist.
GreaterThan(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
GreaterThan(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein BigInteger-Wert ist.
GreaterThan(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
GreaterThanOrEqual(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer oder gleich einem anderen BigInteger-Wert ist.
GreaterThanOrEqual(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als der oder gleich dem Wert einer 64-Bit-Ganzzahl mit Vorzeichen ist.
GreaterThanOrEqual(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als der oder gleich dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen ist.
GreaterThanOrEqual(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein oder gleich einem BigInteger-Wert ist.
GreaterThanOrEqual(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen größer als ein oder gleich einem BigInteger-Wert ist.
Implicit(Byte to BigInteger)	Definiert eine implizite Konvertierung eines Bytewerts ohne Vorzeichen in ein BigInteger-Objekt.
Implicit(Char to BigInteger)	Konvertiert implizit einen Char Wert in eine große ganze Zahl.
Implicit(Int128 to BigInteger)	Konvertiert implizit einen Int128 Wert in eine große ganze Zahl.
Implicit(Int16 to BigInteger)	Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Implicit(Int32 to BigInteger)	Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Implicit(Int64 to BigInteger)	Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Implicit(IntPtr to BigInteger)	Konvertiert implizit einen IntPtr Wert in eine große ganze Zahl.
Implicit(SByte to BigInteger)	Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Konvertiert implizit einen UInt128 Wert in eine große ganze Zahl.
Implicit(UInt16 to BigInteger)	Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Double.
Implicit(UIntPtr to BigInteger)	Konvertiert implizit einen UIntPtr Wert in eine große ganze Zahl.
Increment(BigInteger)	Inkrementiert einen BigInteger-Wert um 1.
Inequality(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob zwei BigInteger-Objekte über unterschiedliche Werte verfügen.
Inequality(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl mit Vorzeichen ungleich sind.
Inequality(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl ohne Vorzeichen ungleich sind.
Inequality(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen und ein BigInteger-Wert ungleich sind.
Inequality(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen und ein BigInteger-Wert ungleich sind.
LeftShift(BigInteger, Int32)	Verschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach links.
LessThan(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als ein anderer BigInteger-Wert ist.
LessThan(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl mit Vorzeichen ist.
LessThan(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
LessThan(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein BigInteger-Wert ist.
LessThan(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als ein BigInteger-Wert ist.
LessThanOrEqual(BigInteger, BigInteger)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner oder gleich einem anderen BigInteger-Wert ist.
LessThanOrEqual(BigInteger, Int64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als oder gleich einer 64-Bit-Ganzzahl mit Vorzeichen ist.
LessThanOrEqual(BigInteger, UInt64)	Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als oder gleich einer 64-Bit-Ganzzahl ohne Vorzeichen ist.
LessThanOrEqual(Int64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein oder gleich einem BigInteger-Wert ist.
LessThanOrEqual(UInt64, BigInteger)	Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als ein oder gleich einem BigInteger-Wert ist.
Modulus(BigInteger, BigInteger)	Gibt den Rest aus der Division zweier angegebener BigInteger-Werte zurück.
Multiply(BigInteger, BigInteger)	Multipliziert zwei angegebene BigInteger-Werte.
OnesComplement(BigInteger)	Gibt das bitweise Einerkomplement eines BigInteger-Werts zurück.
RightShift(BigInteger, Int32)	Verschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach rechts.
Subtraction(BigInteger, BigInteger)	Subtrahiert einen BigInteger-Wert von einem anderen BigInteger-Wert.
UnaryNegation(BigInteger)	Negiert einen angegebenen BigInteger-Wert.
UnaryPlus(BigInteger)	Gibt den Wert des BigInteger-Operanden zurück. (Das Vorzeichen des Operanden wird nicht geändert.)
UnsignedRightShift(BigInteger, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.

Explizite Schnittstellenimplementierungen

IAdditiveIdentity<BigInteger,BigInteger>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<BigInteger>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<BigInteger>.GetShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Werts in Bits ab.
IBinaryInteger<BigInteger>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.
IBinaryInteger<BigInteger>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in eine bestimmte Spanne zu schreiben.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryNumber<BigInteger>.AllBitsSet	Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.
IMultiplicativeIdentity<BigInteger,BigInteger>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
INumber<BigInteger>.MaxNumber(BigInteger, BigInteger)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<BigInteger>.MinNumber(BigInteger, BigInteger)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<BigInteger>.Sign(BigInteger)	Berechnet das Vorzeichen eines Werts.
INumberBase<BigInteger>.IsCanonical(BigInteger)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<BigInteger>.IsComplexNumber(BigInteger)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<BigInteger>.IsFinite(BigInteger)	Bestimmt, ob ein Wert endlich ist.
INumberBase<BigInteger>.IsImaginaryNumber(BigInteger)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<BigInteger>.IsInfinity(BigInteger)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<BigInteger>.IsInteger(BigInteger)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<BigInteger>.IsNaN(BigInteger)	Bestimmt, ob ein Wert NaN ist.
INumberBase<BigInteger>.IsNegativeInfinity(BigInteger)	Bestimmt, ob ein Wert negativ unendlich ist.
INumberBase<BigInteger>.IsNormal(BigInteger)	Bestimmt, ob ein Wert normal ist.
INumberBase<BigInteger>.IsPositiveInfinity(BigInteger)	Bestimmt, ob ein Wert positiv unendlich ist.
INumberBase<BigInteger>.IsRealNumber(BigInteger)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<BigInteger>.IsSubnormal(BigInteger)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<BigInteger>.IsZero(BigInteger)	Bestimmt, ob ein Wert 0 ist.
INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger, BigInteger)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger, BigInteger)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<BigInteger>.Radix	Ruft die Basis für den Typ ab.
INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther, BigInteger)	Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.
INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther, BigInteger)	Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.
INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther, BigInteger)	Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.
INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
ISignedNumber<BigInteger>.NegativeOne	Ruft den Wert -1 für den Typ ab.