System.Numerics.BigInteger-structuur

Het BigInteger type is een onveranderbaar type dat een willekeurig groot geheel getal vertegenwoordigt waarvan de waarde in theorie geen boven- of ondergrens heeft. De leden van het BigInteger type lopen nauw samen met die van andere integrale typen (de Byte, Int16, Int32, Int64SByte, , , UInt16, , en UInt32UInt64 typen). Dit type verschilt van de andere integrale typen in .NET, die een bereik hebben dat wordt aangegeven door hun MinValue en MaxValue eigenschappen.

Een BigInteger-object instantiëren

U kunt een BigInteger object op verschillende manieren instantiëren:

• U kunt het new trefwoord gebruiken en elke integrale of drijvendekommavermogen waarde doorgeven als parameter voor de BigInteger constructor. (Zwevende-kommawaarden worden afgeknot voordat ze worden toegewezen aan de BigInteger.) Het volgende voorbeeld laat zien hoe u het new-trefwoord kunt gebruiken om BigInteger waarden te instantiëren.

  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
  

• U kunt een BigInteger variabele declareren en deze een waarde toewijzen, net zoals elk numeriek type, zolang die waarde een integraal type is. In het volgende voorbeeld wordt de toewijzing gebruikt om een BigInteger waarde te maken op basis van een 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
  

• U kunt een decimaal- of drijvende-kommawaarde toewijzen aan een BigInteger object als u de waarde cast of deze eerst converteert. In het volgende voorbeeld wordt expliciet een Double- en een Decimal-waarde gecast (in C#) of geconverteerd (in Visual Basic) naar een 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
  

Met deze methoden kunt u een BigInteger object instantiëren waarvan de waarde zich in het bereik van een van de bestaande numerieke typen bevindt. U kunt een BigInteger object instantiëren waarvan de waarde het bereik van de bestaande numerieke typen op drie manieren kan overschrijden:

• U kunt het new trefwoord gebruiken en een bytematrix van elke grootte voor de BigInteger.BigInteger constructor opgeven. Voorbeeld:

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

• U kunt de Parse of TryParse methoden aanroepen om de tekenreeksweergave van een getal te converteren naar een BigInteger. Voorbeeld:

  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
  

• U kunt een static methode (Shared in Visual Basic) BigInteger aanroepen die een bewerking uitvoert op een numerieke expressie en een berekend BigInteger resultaat retourneert. In het volgende voorbeeld wordt dit uitgevoerd door het resultaat te pen UInt64.MaxValue en toe te wijzen aan een 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
  

De niet-geïnitialiseerde waarde van een BigInteger is Zero.

Bewerkingen uitvoeren op BigInteger-waarden

U kunt een BigInteger exemplaar gebruiken zoals u elk ander integraal type zou gebruiken. BigInteger overlaadt de standaard numerieke operatoren, waardoor u eenvoudige wiskundige bewerkingen kunt uitvoeren, zoals optellen, aftrekken, delen, vermenigvuldigen en unaire negatie. U kunt ook de standaard numerieke operatoren gebruiken om twee BigInteger waarden met elkaar te vergelijken. Net als de andere integrale typen ondersteunt BigInteger ook de bitsgewijze And, Or, en de operatoren van linkerschuif en rechterschuif. Voor talen die geen aangepaste operators ondersteunen, biedt de BigInteger structuur ook gelijkwaardige methoden voor het uitvoeren van wiskundige bewerkingen. Dit zijn onder andere Add, Divide, Multiply, Negate, Subtract en verschillende andere.

Veel leden van de BigInteger structuur komen rechtstreeks overeen met leden van de andere integrale typen. Daarnaast voegt BigInteger leden toe, zoals de volgende:

• Sign, die een waarde retourneert die het teken van een BigInteger waarde aangeeft.

• Abs, waarmee de absolute waarde van een BigInteger waarde wordt geretourneerd.

• DivRem, die zowel het quotiënt als de rest van een delingsbewerking retourneert.

• GreatestCommonDivisor, die de grootste gemene deler van twee BigInteger waarden retourneert.

Veel van deze extra leden komen overeen met de leden van de Math klasse, die de functionaliteit biedt om te werken met de primitieve numerieke typen.

Veranderlijkheid

In het volgende voorbeeld wordt een BigInteger object geïnstitueerd en wordt vervolgens de waarde met één verhoogd.

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)

Hoewel dit voorbeeld de waarde van het bestaande object lijkt te wijzigen, is dit niet het geval. BigInteger objecten zijn onveranderbaar, wat betekent dat de algemene taalruntime daadwerkelijk een nieuw BigInteger object maakt en deze een waarde toewijst die groter is dan de vorige waarde. Dit nieuwe object wordt vervolgens teruggezet naar de aanroeper.

Hoewel dit proces transparant is voor de beller, wordt er wel een prestatiestraf opgelegd. In sommige gevallen, met name wanneer herhaalde bewerkingen worden uitgevoerd in een lus op zeer grote BigInteger waarden, kan die prestatiestraf aanzienlijk zijn. In het volgende voorbeeld wordt een bewerking bijvoorbeeld herhaaldelijk tot een miljoen keer uitgevoerd en wordt een BigInteger waarde verhoogd telkens wanneer de bewerking slaagt.

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 dat geval kunt u de prestaties verbeteren door alle tussenliggende toewijzingen uit te voeren voor een Int32 variabele. De uiteindelijke waarde van de variabele kan vervolgens worden toegewezen aan het BigInteger object wanneer de lus wordt afgesloten. In het volgende voorbeeld ziet u een afbeelding.

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

Bytematrices en hexadecimale tekenreeksen

Als u waarden converteert BigInteger naar bytematrices of als u bytematrices converteert naar BigInteger waarden, moet u rekening houden met de volgorde van bytes. De BigInteger structuur verwacht dat de afzonderlijke bytes in een bytematrix worden weergegeven in de little-endian-volgorde (dat wil gezegd, de lagere volgorde bytes van de waarde voorafgaan aan de bytes in hogere volgorde). U kunt een BigInteger waarde afronden door de ToByteArray methode aan te roepen en vervolgens de resulterende bytematrix door te geven aan de BigInteger(Byte[]) constructor, zoals in het volgende voorbeeld wordt weergegeven.

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

Als u een BigInteger waarde wilt instantiëren van een bytematrix die een waarde van een ander integraal type vertegenwoordigt, kunt u de integrale waarde doorgeven aan de BitConverter.GetBytes methode en vervolgens de resulterende bytematrix doorgeven aan de BigInteger(Byte[]) constructor. In het volgende voorbeeld wordt een BigInteger waarde geïnstitueerd van een bytematrix die een Int16 waarde vertegenwoordigt.

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

In de BigInteger structuur wordt ervan uitgegaan dat negatieve waarden worden opgeslagen met behulp van de complementweergave van twee. Omdat de BigInteger structuur een numerieke waarde zonder vaste lengte vertegenwoordigt, interpreteert de BigInteger(Byte[]) constructor altijd de belangrijkste bit van de laatste byte in de matrix als tekenbit. Om te voorkomen dat de BigInteger(Byte[]) constructor de twee-complementrepresentatie van een negatieve waarde verwart met de teken-en-grootte-weergave van een positieve waarde, moeten bij positieve waarden waarin de meest significante bit van de laatste byte in de byte-array normaal gesproken wordt ingesteld, een extra byte worden toegevoegd waarvan de waarde 0 is. Bijvoorbeeld, 0xC0 0xBD 0xF0 0xFF is de little-endian hexadecimale weergave van ofwel -1.000.000 of 4.293.967.296. Omdat de belangrijkste bit van de laatste byte in deze matrix is ingeschakeld, wordt de waarde van de bytematrix geïnterpreteerd door de BigInteger(Byte[]) constructor als -1.000.000. Om een BigInteger waarvan de waarde positief is te creëren, moet een byte-array waarvan de elementen 0xC0 0xBD 0xF0 0xFF 0x00 zijn worden doorgegeven aan de constructor. In het volgende voorbeeld ziet u dit.

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

Bytematrices die zijn gemaakt door de ToByteArray methode op basis van positieve waarden, bevatten deze extra byte met nulwaarde. Daarom kan de BigInteger structuur waarden met succes rondsturen door ze toe te wijzen aan byte-arrays en ze vervolgens daarvan te herstellen, zoals in het volgende voorbeeld wordt weergegeven.

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

Mogelijk moet u echter deze extra nulwaarde-byte toevoegen aan byte-arrays die dynamisch worden gemaakt door de ontwikkelaar of die worden geretourneerd door methoden waarmee ongecodeerde gehele getallen worden omgezet naar byte-arrays (zoals BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)en BitConverter.GetBytes(UInt64)).

Bij het parseren van een hexadecimale tekenreeks gaan de BigInteger.Parse(String, NumberStyles) en BigInteger.Parse(String, NumberStyles, IFormatProvider) methoden ervan uit dat als de belangrijkste bit van de eerste byte in de tekenreeks is ingesteld, of als het eerste hexadecimale cijfer van de tekenreeks de onderste vier bits van een bytewaarde vertegenwoordigt, de waarde wordt weergegeven met behulp van de complementweergave van twee. Zo vertegenwoordigen zowel 'FF01' als 'F01' de decimale waarde -255. Als u positieve waarden wilt onderscheiden van negatieve waarden, moeten positieve waarden een voorloopnul bevatten. De relevante overloads van de ToString-methode voegen een voorloopnul toe aan de geretourneerde hexadecimale tekenreeks voor positieve waarden, wanneer ze het formaat "X" krijgen. Dit maakt het mogelijk om BigInteger waarden rond te sturen door middel van de ToString en Parse methoden, zoals in het volgende voorbeeld wordt getoond.

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.

De hexadecimale tekenreeksen die zijn gemaakt door het aanroepen van de ToString methoden van de andere integrale typen of de overbelastingen van de ToString methode die een toBase parameter bevatten, geven echter niet het teken van de waarde of het brongegevenstype aan waarvan de hexadecimale tekenreeks is afgeleid. Voor het instantiëren van een BigInteger waarde uit een dergelijke tekenreeks is extra logica vereist. In het volgende voorbeeld ziet u één mogelijke implementatie.

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.