BigInteger BigInteger BigInteger BigInteger Struct

Definition

Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.Represents an arbitrarily large signed integer.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Vererbung
BigIntegerBigIntegerBigIntegerBigInteger
Attribute
Implementiert

Hinweise

Die BigInteger Typ ist ein unveränderlicher Typ, der eine beliebig große ganze Zahl darstellt, deren Wert theoretisch keine Ober- und Untergrenze hat.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Die Mitglieder der BigInteger -Typs ähneln im Wesentlichen denen der anderen ganzzahligen Typen (die Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, und UInt64 Typen).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Dieser Typ unterscheidet sich von der anderen ganzzahligen Typen in der .NET Framework.NET Framework, die durch einen Bereich haben ihre MinValue und MaxValue Eigenschaften.This type differs from the other integral types in the .NET Framework.NET Framework, which have a range indicated by their MinValue and MaxValue properties.

Hinweis

Da die BigInteger Typ ist unveränderlich (finden Sie unter Veränderlichkeit und BigInteger-Struktur) und da er keine oberen und unteren Grenzen hat ein OutOfMemoryException ausgelöst werden kann, für jeden Vorgang, der bewirkt, dass eine BigInteger Wert zu vergrößern. große.Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

Instanziieren eines Objekts BigIntegerInstantiating a BigInteger Object

Instanziieren Sie ein BigInteger Objekts auf verschiedene Weise:You can instantiate a BigInteger object in several ways:

  • Können Sie die new Schlüsselwort, und geben Sie einen beliebigen ganzzahligen oder Gleitkomma-Wert als Parameter an die BigInteger Konstruktor.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Gleitkommazahlen-Punktwerte werden abgeschnitten, bevor sie zugewiesen sind die BigInteger.) Das folgende Beispiel veranschaulicht, wie Sie mit der new Schlüsselwort zum Instanziieren BigInteger Werte.(Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

    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 deklarieren, ein BigInteger Variable und weisen Sie ein Wert wie würde alle numerischen Typen, solange dieser Wert ein ganzzahliger Typ ist.You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. Im folgenden Beispiel wird die Zuweisung zum Erstellen einer BigInteger Wert aus einer Int64.The following example uses assignment to create a BigInteger value from an Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • Sie können einen decimal "oder" Gleitkomma-Wert zum Zuweisen einer BigInteger Objekt, wenn Sie wandeln Sie den Wert, oder konvertieren es zuerst.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. Im folgenden Beispiel wird explizit umgewandelt (in C#) oder (in Visual Basic) konvertiert eine Double und Decimal -Werts in einen BigInteger.The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to 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      
    

Diese Methoden ermöglichen es Ihnen, zu instanziieren einer BigInteger Objekt, dessen Wert in den Wertebereich eines vorhandenen numerischen Typen nur.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Instanziieren Sie ein BigInteger Objekt, dessen Wert des Bereichs von vorhandenen numerischen Typen in einer von drei Methoden überschreiten kann:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Können Sie die new Schlüsselwort, und geben Sie ein Byte-Array von beliebiger Größe für die BigInteger.BigInteger Konstruktor.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Beispiel:For example:

    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).
    
  • Rufen Sie die Parse oder TryParse Methoden konvertieren die angegebene Zeichenfolgendarstellung einer Zahl in eine BigInteger.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Beispiel:For example:

    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
    
  • Rufen Sie eine static (Shared in Visual Basic) BigInteger -Methode, die einen Vorgang für einen numerischen Ausdruck ausführt, und gibt einen berechneten BigInteger Ergebnis.You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. Durch cuberstellung wird im folgende Beispiel UInt64.MaxValue und das Ergebnis, das Zuweisen einer BigInteger.The following example does this by cubing UInt64.MaxValue and assigning the result to 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
    

Den nicht initialisierten Wert des einem BigInteger ist Zero.The uninitialized value of a BigInteger is Zero.

Ausführen von Vorgängen für BigInteger-WertePerforming Operations on BigInteger Values

Sie können eine BigInteger Instanz, wie Sie einen anderen ganzzahligen Typ verwenden würden.You can use a BigInteger instance as you would use any other integral type. BigInteger Überladungen die standardmäßigen numerischen Operatoren, damit Sie grundlegende mathematische Operationen wie Addition, Subtraktion, Division, Multiplikation, Subtraktion, Negation und unäre Negation ausführen können.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. Sie können auch die standardmäßigen numerischen Operatoren verwenden, um zwei BigInteger Werte miteinander.You can also use the standard numeric operators to compare two BigInteger values with each other. Wie die anderen ganzzahligen Typen BigInteger unterstützt auch das bitweise And, Or, XOr, linke UMSCHALTTASTE und right Shift-Operatoren.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Für Sprachen, die keine benutzerdefinierte Operatoren, unterstützen die BigInteger Struktur stellt auch die entsprechende Methoden für mathematische Operationen ausführen.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Dazu gehören Add, Divide, Multiply, Negate, Subtract, und andere.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Viele Elemente der der BigInteger Struktur direkt auf Mitglieder der anderen ganzzahligen Typen entsprechen.Many members of the BigInteger structure correspond directly to members of the other integral types. Darüber hinaus BigInteger fügt Elemente wie den folgenden:In addition, BigInteger adds members such as the following:

Viele dieser zusätzlichen Member die Member der entsprechen den Math -Klasse, die die Funktionen für die Arbeit mit den primitiven numerischen Typen bereitstellt.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Veränderlichkeit und BigInteger-StrukturMutability and the BigInteger Structure

Das folgende Beispiel instanziiert ein BigInteger Objekt aus, und klicken Sie dann den Wert um eins erhöht.The following example instantiates a BigInteger object and then increments its value by one.

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 angezeigt wird, um den Wert des vorhandenen Objekts ändern, ist dies nicht der Fall.Although this example appears to modify the value of the existing object, this is not the case. BigInteger -Objekte sind unveränderlich, was bedeutet, dass intern, die common Language Runtime erstellt tatsächlich ein neues BigInteger -Objekt und weist ihr den Wert eins größer ist als der vorherige Wert.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. Dieses neue Objekt wird an den Aufrufer zurückgegeben.This new object is then returned to the caller.

Hinweis

Die numerischen Typen in .NET Framework sind ebenfalls unveränderlich.The other numeric types in the .NET Framework are also immutable. Aber da die BigInteger Typ verfügt über keine Ober- und Untergrenze, seine Werte werden sehr groß und einen messbaren Einfluss auf die Leistung haben können.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Obwohl dieser Prozess für den Aufrufer transparent ist, es zu Leistungseinbußen.Although this process is transparent to the caller, it does incur a performance penalty. In einigen Fällen, insbesondere wenn wiederholte Vorgänge werden in einer Schleife für sehr große BigInteger Werte, diese Leistungseinbußen kann erheblich sein.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Beispielsweise in folgenden Beispiel ein Vorgang ausgeführt wird wiederholt, bis zu eine Million Mal, und ein BigInteger Wert wird um eins erhöht, jedes Mal, wenn der Vorgang erfolgreich ist.For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

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 diesem Fall können Sie die Leistung verbessern, durch Ausführen von alle Zwischenergebnisse Zuweisungen zu einer Int32 Variable.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Der endgültige Wert der Variablen kann dann zugewiesen werden, auf die BigInteger Objekt, wenn die Schleife beendet wird.The final value of the variable can then be assigned to the BigInteger object when the loop exits. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

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 Byte-Arrays und Zeichenfolgen mit hexadezimal-Working with Byte Arrays and Hexadecimal Strings

Wenn Sie konvertieren BigInteger Werte auf Byte-Arrays, oder wenn Sie Bytearrays zu konvertieren BigInteger Werte, berücksichtigen Sie die Reihenfolge der Bytes.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. Die BigInteger Struktur erwartet, dass die einzelnen Bytes in einem Bytearray in little-Endian-Reihenfolge angezeigt werden (d. h. die niederwertigen Bytes des Wertes vor stehen die höherwertigen Bytes).The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). Sie können einen Roundtrip eine BigInteger -Wert durch Aufrufen der ToByteArray -Methode und dann das resultierende Byte-array an die BigInteger(Byte[]) Konstruktor, wie im folgenden Beispiel gezeigt.You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

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

Instanziiert eine BigInteger Wert aus einem Bytearray, das einen Wert eines anderen ganzzahligen Typs darstellt, können Sie den ganzzahligen Wert zu übergeben die BitConverter.GetBytes Methode, und klicken Sie dann übergeben, das sich ergebende Byte-array an, die BigInteger(Byte[]) Konstruktor.To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. Das folgende Beispiel instanziiert ein BigInteger Wert aus einem Bytearray, das stellt ein Int16 Wert.The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

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 wird davon ausgegangen, dass negative Werte mit zwei der Ergänzung Darstellung gespeichert werden.The BigInteger structure assumes that negative values are stored by using two's complement representation. Da die BigInteger Struktur darstellt, einen numerischen Wert ohne feste Länge, die BigInteger(Byte[]) Konstruktor immer das höchstwertige Bit der das letzte Byte im Array als Vorzeichenbit interpretiert.Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. Um zu verhindern, dass die BigInteger(Byte[]) -Konstruktor von verwirrend erscheinen die beiden Komplement Darstellung eines negativen Werts mit dem Zeichen und Größe Zeichenfolgendarstellung ein positiver Wert sein, positive Werte in der die meisten niederwertigste Bit des letzten Bytes im Bytearray Normalerweise wäre Set sollte ein zusätzlicher Byte, deren Wert 0 gleich, enthalten.To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. Z. B. 0xC0 0xBD 0xF0 0xFF ist die hexadezimale Darstellung der little-Endian--1,000,000 oder 4,293,967,296.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Da das höchstwertige Bit der das letzte Byte im Array auf befindet, wird der Wert des Bytearrays von interpretiert werden die BigInteger(Byte[]) Konstruktor als-1.000.000.Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. Instanziiert eine BigInteger , deren Wert ist positiv, ein Byte-Array, dessen Elemente 0xC0, 0xBD 0xF0 0xFF 0x00 muss an den Konstruktor übergeben werden.To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. Dies wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this.

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      

Byte-Arrays erstellt werden, indem die ToByteArray -Methode von positive Werte enthalten, diese zusätzliche NULL-Wert-Byte.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Aus diesem Grund die BigInteger Struktur können erfolgreich in Werte, indem Sie zum Zuweisen und dann wiederhergestellt werden diese Bytearrays, wie im folgenden Beispiel gezeigt.Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

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

Allerdings müssen möglicherweise Bytearrays, die dynamisch vom Entwickler erstellt werden, oder durch Methoden, die ganzen Zahlen ohne Vorzeichen in Bytearrays zu konvertieren zurückgegeben werden, diese zusätzlichen Byte mit dem Wert 0 (null) hinzugefügt (z. B. BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), und BitConverter.GetBytes(UInt64)).However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

Bei der Analyse einer hexadezimalen Zeichenfolge, die BigInteger.Parse(String, NumberStyles) und BigInteger.Parse(String, NumberStyles, IFormatProvider) Methoden davon aus, dass wenn das höchstwertige Bit des ersten Bytes in der Zeichenfolge festgelegt ist, oder wenn die erste hexadezimale Ziffer der Zeichenfolge die unteren vier Bits, der ein Byte-Wert darstellt, der Wert ist Mithilfe von zwei der Ergänzung Darstellung dargestellt.When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. Zum Beispiel darstellen sowohl "FF01" und "F01" den Dezimalwert-255 dar.For example, both "FF01" and "F01" represent the decimal value -255. Um positive von negativen Werten zu unterscheiden, sollte positive Werte eine führende 0 (null) enthalten.To differentiate positive from negative values, positive values should include a leading zero. Die entsprechenden Überladungen der ToString Methode, wenn sie mit die Formatzeichenfolge "X" übergeben werden, hinzufügen eine führende Null in der zurückgegebenen hexadezimale Zeichenfolge für positive Werte.The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. Dies ermöglicht einen Roundtrip BigInteger Werte mithilfe der ToString und Parse Methoden, wie im folgenden Beispiel gezeigt.This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

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.

Allerdings die Hexadezimalzeichenfolgen erstellt durch Aufrufen der ToString Methoden der anderen ganzzahligen Typen oder die Überladungen der der ToString Methode, die implizit enthalten eine toBase Parameter nicht angegeben wird, die Vorzeichen des Werts oder der Quelldatentyp aus dem die hexadezimale Zeichenfolge abgeleitet wurde.However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. Instanziieren erfolgreich eine BigInteger Wert aus einer solchen Zeichenfolge ist zusätzliche Logik erforderlich.Successfully instantiating a BigInteger value from such a string requires some additional logic. Im folgenden Beispiel wird eine mögliche Implementierung.The following example provides one possible implementation.

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[]) BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[])

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einem Bytearray.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal)

Initialisiert eine neue Instanz der BigInteger-Struktur mit einem Decimal-Wert.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double) BigInteger(Double) BigInteger(Double) BigInteger(Double)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit doppelter Genauigkeit.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32) BigInteger(Int32) BigInteger(Int32) BigInteger(Int32)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl mit Vorzeichen.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64) BigInteger(Int64) BigInteger(Int64) BigInteger(Int64)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 64-Bit-Ganzzahl mit Vorzeichen.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single) BigInteger(Single) BigInteger(Single) BigInteger(Single)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit einfacher Genauigkeit.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl ohne Vorzeichen.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64)

Initialisiert eine neue Instanz der BigInteger-Struktur mit dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Eigenschaften

IsEven IsEven IsEven IsEven

Gibt an, ob der Wert des aktuellen BigInteger-Objekts eine gerade Zahl ist.Indicates whether the value of the current BigInteger object is an even number.

IsOne IsOne IsOne IsOne

Gibt an, ob der Wert des aktuellen BigInteger-Objekts One ist.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo

Gibt an, ob der Wert des aktuellen BigInteger-Objekts eine Potenz von Zwei ist.Indicates whether the value of the current BigInteger object is a power of two.

IsZero IsZero IsZero IsZero

Gibt an, ob der Wert des aktuellen BigInteger-Objekts Zero ist.Indicates whether the value of the current BigInteger object is Zero.

MinusOne MinusOne MinusOne MinusOne

Ruft einen Wert ab, der die Zahl -1 darstellt.Gets a value that represents the number negative one (-1).

One One One One

Ruft einen Wert ab, der die Zahl 1 darstellt.Gets a value that represents the number one (1).

Sign Sign Sign Sign

Ruft eine Zahl ab, die das Vorzeichen (negativ, positiv, oder 0 (null)) des aktuellen BigInteger-Objekts angibt.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero Zero Zero Zero

Ruft einen Wert ab, der die Zahl null (0) darstellt.Gets a value that represents the number 0 (zero).

Methoden

Abs(BigInteger) Abs(BigInteger) Abs(BigInteger) Abs(BigInteger)

Ruft den absoluten Wert eines BigInteger-Objekts ab.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger)

Addiert zwei BigInteger-Werte und gibt das Ergebnis zurück.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) 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.Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.

CompareTo(Object) CompareTo(Object) CompareTo(Object) 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.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64) 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.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

CompareTo(Int64) CompareTo(Int64) CompareTo(Int64) 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.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger) 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.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger)

Dividiert einen BigInteger-Wert durch einen anderen und gibt das Ergebnis zurück.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) 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.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(Int64) Equals(Int64) Equals(Int64) 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.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger) Equals(BigInteger) Equals(BigInteger) Equals(BigInteger)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger-Objekt über den gleichen Wert verfügen.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64) Equals(UInt64) Equals(UInt64) 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.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Gibt den Hashcode für das aktuelle BigInteger-Objekt zurück.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger)

Sucht den größten gemeinsamen Divisor von zwei BigInteger-Werten.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger) Log(BigInteger) Log(BigInteger) Log(BigInteger)

Gibt den natürlichen Logarithmus (zur Basis e) der angegebenen Zahl zurück.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double)

Gibt den Logarithmus einer angegebenen Zahl bezüglich einer angegebenen Basis zurück.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger) Log10(BigInteger) Log10(BigInteger) Log10(BigInteger)

Gibt den Logarithmus einer angegebenen Zahl zur Basis 10 zurück.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger)

Gibt den größeren der beiden BigInteger-Werte zurück.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger)

Gibt den kleineren der beiden BigInteger-Werte zurück.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger)

Führt eine Modulodivision für eine zur Potenz einer anderen Zahl erhobene Zahl aus.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Gibt das Produkt der beiden BigInteger-Werte zurück.Returns the product of two BigInteger values.

Negate(BigInteger) Negate(BigInteger) Negate(BigInteger) Negate(BigInteger)

Negiert einen angegebenen BigInteger-Wert.Negates a specified BigInteger value.

Parse(String) Parse(String) Parse(String) Parse(String)

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende BigInteger.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32)

Potenziert einen BigInteger-Wert mit einem angegebenen Wert.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger)

Führt die Ganzzahldivision von zwei BigInteger-Werten aus und gibt den Rest zurück.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger)

Subtrahiert einen BigInteger-Wert von einem anderen und gibt das Ergebnis zurück.Subtracts one BigInteger value from another and returns the result.

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

Konvertiert einen BigInteger-Wert in ein Bytearray.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)
ToString() ToString() ToString() ToString()

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(String)

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) 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.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger)
TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger) 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.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) 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.Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Operatoren

Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger)

Addiert die Werte von zwei angegebenen BigInteger-Objekten.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger)

Führt eine bitweise And-Operation für zwei BigInteger-Werte aus.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger)

Führt eine bitweise Or-Operation für zwei BigInteger-Werte aus.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger)

Dekrementiert einen BigInteger-Wert um 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger)

Dividiert einen angegebenen BigInteger-Wert durch einen anderen angegebenen BigInteger-Wert mit einer Ganzzahldivision.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger) 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.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64) 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.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob die Werte von zwei BigInteger-Objekten gleich sind.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) 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.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) 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.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger)

Führt eine bitweise exklusive Or-Operation (XOr-Operation) für zwei BigInteger-Werte aus.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Definiert eine explizite Konvertierung eines Decimal-Objekts in einen BigInteger-Wert.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Definiert eine explizite Konvertierung eines Double-Werts in einen BigInteger-Wert.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Bytewert ohne Vorzeichen.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Decimal-Wert.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Double-Wert.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl mit Vorzeichen.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl mit Vorzeichen.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl mit Vorzeichen.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen 8-Bit-Wert mit Vorzeichen.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Gleitkommawert mit einfacher Genauigkeit.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl ohne Vorzeichen.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl ohne Vorzeichen.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Double.The compliant alternative is Double.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Definiert eine explizite Konvertierung eines Single-Werts in einen BigInteger-Wert.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger)

Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein BigInteger-Wert ist.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) 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.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als ein anderer BigInteger-Wert ist.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) 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.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) 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.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer oder gleich einem anderen BigInteger-Wert ist.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) 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.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) 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.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Implicit(Int64 to BigInteger).The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Implicit(Int32 to BigInteger).The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger)

Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist BigInteger(Int32).The compliant alternative is BigInteger(Int32).

Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger)

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die kompatible Alternative ist Double.The compliant alternative is Double.

Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger)

Definiert eine implizite Konvertierung eines Bytewerts ohne Vorzeichen in ein BigInteger-Objekt.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger)

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Increment(BigInteger) Increment(BigInteger) Increment(BigInteger) Increment(BigInteger)

Inkrementiert einen BigInteger-Wert um 1.Increments a BigInteger value by 1.

Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger)

Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen und ein BigInteger-Wert ungleich sind.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob zwei BigInteger-Objekte über unterschiedliche Werte verfügen.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl ohne Vorzeichen ungleich sind.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger)

Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen und ein BigInteger-Wert ungleich sind.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl mit Vorzeichen ungleich sind.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32)

Verschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach links.Shifts a BigInteger value a specified number of bits to the left.

LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger)

Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein BigInteger-Wert ist.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl mit Vorzeichen ist.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als ein anderer BigInteger-Wert ist.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger)

Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als ein BigInteger-Wert ist.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) 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.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner oder gleich einem anderen BigInteger-Wert ist.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) 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.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) 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.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) 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.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger)

Gibt den Rest aus der Division zweier angegebener BigInteger-Werte zurück.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Multipliziert zwei angegebene BigInteger-Werte.Multiplies two specified BigInteger values.

OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger)

Gibt das bitweise Einerkomplement eines BigInteger-Werts zurück.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32)

Verschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach rechts.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger)

Subtrahiert einen BigInteger-Wert von einem anderen BigInteger-Wert.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger)

Negiert einen angegebenen BigInteger-Wert.Negates a specified BigInteger value.

UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger)

Gibt den Wert des BigInteger-Operanden zurück.Returns the value of the BigInteger operand. (Das Vorzeichen des Operanden wird nicht geändert.)(The sign of the operand is unchanged.)

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

Gilt für: