System.Numerics.BigInteger-Struct

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Der BigInteger Typ ist ein unveränderlicher Typ, der eine beliebig große ganze Zahl darstellt, deren Wert in der Theorie keine oberen oder unteren Grenzen aufweist. Die Elemente von BigInteger entsprechen eng denen anderer integraler Typen (Typen Byte, Int16, Int32, Int64, SByte, UInt16, UInt32 und UInt64). Dieser Typ unterscheidet sich von den anderen Ganzzahltypen in .NET, die einen Bereich haben, der durch ihre MinValue- und MaxValue-Eigenschaften bestimmt wird.

Hinweis

Da der BigInteger Typ unveränderlich ist (siehe Mutability) und keine oberen oder unteren Grenzen hat, kann bei jeder Operation, die dazu führt, dass ein OutOfMemoryException Wert zu groß wird, ein BigInteger ausgelöst werden.

Instanziieren eines BigInteger-Objekts

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

• Sie können das new Schlüsselwort verwenden und einen beliebigen integralen oder Gleitkommawert als Parameter für den BigInteger Konstruktor bereitstellen. (Floating-Point-Werte werden abgeschnitten, bevor sie dem BigInteger zugewiesen werden.) Das folgende Beispiel veranschaulicht, wie das Schlüsselwort new verwendet wird, um BigInteger-Werte zu instanziieren.

  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 ihm einen Wert wie jeder numerische Typ zuweisen, solange dieser Wert ein integraler Typ ist. Im folgenden Beispiel wird eine Zuweisung verwendet, um einen BigInteger-Wert aus einem Int64-Element zu 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 Fließkommawert zuweisen, wenn Sie den Wert zuerst casten oder konvertieren. Das folgende Beispiel castet (in C#) oder konvertiert (in Visual Basic) einen Double und einen Decimal-Wert explizit 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 sich nur im Bereich eines der vorhandenen numerischen Typen befindet. 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 das new Schlüsselwort verwenden und dem Konstruktor ein Bytearray mit beliebiger Größe BigInteger.BigInteger 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 {newBigInt} (or 0x{newBigInt:x}).");
  // The example displays the following output:
  //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
  

  Dim byteArray() As Byte = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
  Dim newBigInt As New BigInteger(byteArray)
  Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)
  ' The example displays the following output:
  '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
  

• Sie können die Methoden Parse oder TryParse aufrufen, um die Zeichenfolgendarstellung einer Zahl in eine BigInteger zu 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 '{positiveString}' to a BigInteger value.");
  }
  
  if (BigInteger.TryParse(negativeString, out negBigInt))
    Console.WriteLine(negBigInt);
  else
     Console.WriteLine($"Unable to convert the string '{negativeString}' to a BigInteger value.");
  
  // The example displays the following output:
  //   9.1389681247993671255432112E+31
  //   -9.0315837410896312071002088037E+34
  

  Dim positiveString As String = "91389681247993671255432112000000"
  Dim negativeString As String = "-90315837410896312071002088037140000"
  Dim posBigInt As BigInteger = 0
  Dim negBigInt As BigInteger = 0
  
  Try
      posBigInt = BigInteger.Parse(positiveString)
      Console.WriteLine(posBigInt)
  Catch e As FormatException
      Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                        positiveString)
  End Try
  
  If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
  Else
      Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                         negativeString)
  End If
  ' The example displays the following output:
  '   9.1389681247993671255432112E+31
  '   -9.0315837410896312071002088037E+34
  

• Sie können eine static (Shared in Visual Basic) BigInteger -Methode aufrufen, die einen Vorgang für einen numerischen Ausdruck ausführt und ein berechnetes BigInteger Ergebnis zurückgibt. Das folgende Beispiel tut dies, indem es UInt64.MaxValue kubiert und das Ergebnis einem BigInteger zuweist.

  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 eines BigInteger ist Zero.

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

Sie können eine BigInteger Instanz wie jeden anderen integralen Typ verwenden. BigInteger überlastet die standardmäßigen numerischen Operatoren, damit Sie grundlegende mathematische Vorgänge wie Addition, Subtraktion, Division, Multiplikation und unäre Negation ausführen können. Sie können auch die standardmäßigen numerischen Operatoren verwenden, um zwei BigInteger Werte miteinander zu vergleichen. Wie bei den anderen integralen Typen unterstützt BigInteger auch die bitweisen And, Or, XOr Operatoren sowie die linke und rechte Verschiebung. Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, stellt die BigInteger Struktur auch entsprechende Methoden zum Ausführen mathematischer Vorgänge bereit. Dazu gehören , Add, Divide, Multiply, Negate, Subtractund mehrere andere.

Viele Elemente der BigInteger Struktur entsprechen direkt mitgliedern der anderen integralen Typen. Darüber hinaus fügt BigInteger Mitglieder wie die folgenden hinzu:

• 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 für die Arbeit mit den primitiven numerischen Typen bereitstellt.

Veränderlichkeit

Im folgenden Beispiel wird ein BigInteger Objekt instanziiert und anschließend der 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 geändert wird, ist dies nicht der Fall. BigInteger Objekte sind unveränderlich, was bedeutet, dass intern die Common Language Runtime 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 oberen oder unteren Grenzen aufweist, können die Werte extrem groß werden und eine messbare Auswirkung auf die Leistung haben.

Obwohl dieser Prozess für den Aufrufer transparent ist, hat er einen Leistungsverlust zur Folge. In einigen Fällen können die Leistungseinbußen erheblich sein, insbesondere wenn wiederholte Vorgänge in einer Schleife mit sehr großen BigInteger-Werten ausgeführt werden. Im folgenden Beispiel wird beispielsweise ein Vorgang wiederholt bis zu einer Million Mal ausgeführt, und ein BigInteger Wert wird jedes Mal erhöht, wenn der Vorgang erfolgreich ist.

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, indem Sie alle Zwischenzuweisungen für eine Int32 Variable ausführen. Der endgültige Wert 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

Bytearrays und hexadezimale Zeichenfolgen

Wenn Sie BigInteger-Werte in Byte-Arrays konvertieren oder wenn Sie Byte-Arrays in BigInteger-Werte konvertieren, müssen Sie die Reihenfolge der Bytes berücksichtigen. Die BigInteger Struktur erwartet, dass die einzelnen Bytes in einem Byte-Array in kleiner Endian-Reihenfolge vorliegen (d. h. die niederwertigen Bytes des Werts gehen den höherwertigen Bytes voraus). Sie können einen BigInteger Wert runden, 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, der 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, das 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 wichtigste Bit des letzten Bytes im Array als Zeichenbit. Um zu verhindern, dass der BigInteger(Byte[]) Konstruktor die Zweierkomplementdarstellung eines negativen Werts mit dem Vorzeichen und der Größe eines positiven Werts verwechselt, sollten positive Werte, bei denen das höchstwertige Bit des letzten Bytes im Byte-Array normalerweise gesetzt würde, ein zusätzliches Byte enthalten, dessen Wert 0 ist. Zum Beispiel ist 0xC0 0xBD 0xF0 0xFF die Little-Endian-Hexadezimaldarstellung von entweder -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. Im folgenden Beispiel wird dies 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 wurden, enthalten dieses extra nullwertige Byte. Daher kann die BigInteger-Struktur Werte erfolgreich umwandeln, indem sie sie Byte-Arrays zuweist und dann aus diesen wieder zurückholt, wie das folgende Beispiel zeigt.

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 jedoch dieses zusätzliche Nullwert-Byte zu Bytearrays hinzufügen, die entweder dynamisch vom Entwickler erstellt werden oder von Methoden zurückgegeben werden, die nicht signierte ganze Zahlen in Bytearrays konvertieren (z. B. BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32) und BitConverter.GetBytes(UInt64)).

Beim Parsen einer hexadezimalen Zeichenfolge gehen die Methoden BigInteger.Parse(String, NumberStyles) und BigInteger.Parse(String, NumberStyles, IFormatProvider) davon aus, dass der Wert im Zweierkomplement dargestellt wird, 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 eines Byte-Wertes darstellt. Beispielsweise stellen sowohl "FF01" als auch "F01" den Dezimalwert -255 dar. Um positive Werte von negativen Werten zu unterscheiden, sollten positive Werte eine führende Null enthalten. Die entsprechenden Überladungen der ToString-Methode fügen der zurückgegebenen hexadezimalen Zeichenfolge für positive Werte eine führende Null hinzu, wenn ihnen die Formatfolge "X" übergeben wird. Dies ermöglicht den Roundtrip der BigInteger Werte mithilfe der ToString- und Parse-Methoden, 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 {negativeNumber:N0} to {negativeHex} back to {negativeNumber2:N0}.");
Console.WriteLine($"Converted {positiveNumber:N0} to {positiveHex} back to {positiveNumber2:N0}.");
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.

Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

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

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

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

Die hexadezimalen Sätze, die durch den Aufruf der ToString-Methoden der anderen integralen Typen oder der Überladungen der ToString-Methode, die einen toBase-Parameter enthalten, entstehen, geben jedoch weder das Vorzeichen des Wertes noch den Quelldatentyp an, von dem die Hexadezimalzeichenfolge abgeleitet wurde. Das erfolgreiche Instanziieren eines BigInteger Werts aus einer solchen Zeichenfolge erfordert eine 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 ByteHexExample2
{
    public static void Main()
    {
        uint positiveNumber = 4039543321;
        int negativeNumber = -255423975;

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

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

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

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

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

Imports System.Globalization
Imports System.Numerics

Public Structure HexValue
    Public Sign As Integer
    Public Value As String
End Structure

Module Example2
    Public Sub Main()
        Dim positiveNumber As UInteger = 4039543321
        Dim negativeNumber As Integer = -255423975

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

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

        ' Round-trip the hexadecimal values to BigInteger values.
        Dim hexString As String
        Dim positiveBigInt, negativeBigInt As BigInteger

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

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

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