System.Numerics.BigInteger struct

Den BigInteger typen är en oföränderlig typ som representerar ett godtyckligt stort heltal vars värde i teorin inte har några övre eller nedre gränser. Medlemmarna i den BigInteger typen är nära parallella med andra typer av integraler (Byte, Int16, Int32, Int64, SByte, UInt16, UInt32och UInt64 typer). Den här typen skiljer sig från de andra integraltyperna i .NET, som har ett intervall som anges av deras MinValue och MaxValue egenskaper.

Instansiera ett BigInteger-objekt

Du kan instansiera ett BigInteger objekt på flera sätt:

• Du kan använda nyckelordet new och ange ett heltals- eller flyttalsvärde som en parameter till BigInteger konstruktorn. (Flyttalsvärden trunkeras innan de tilldelas BigInteger.) Följande exempel illustrerar hur du använder nyckelordet new för att instansiera BigInteger-värden.

  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
  

• Du kan deklarera en BigInteger variabel och tilldela den ett värde precis som vilken numerisk typ som helst, så länge värdet är en integrerad typ. I följande exempel används tilldelning för att skapa ett BigInteger-värde från en 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
  

• Du kan tilldela ett decimal- eller flyttalsvärde till ett BigInteger objekt om du gjuter värdet eller konverterar det först. I följande exempel konverteras (i C#) eller (i Visual Basic) en Double och ett Decimal värde till en 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
  

Med de här metoderna kan du instansiera ett BigInteger objekt vars värde ligger inom intervallet för en av de befintliga numeriska typerna. Du kan instansiera ett BigInteger objekt vars värde kan överskrida intervallet för de befintliga numeriska typerna på något av tre sätt:

• Du kan använda nyckelordet new och ange en bytematris av valfri storlek för BigInteger.BigInteger konstruktorn. Till exempel:

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

• Du kan anropa metoderna Parse eller TryParse för att konvertera strängrepresentationen av ett tal till en BigInteger. Till exempel:

  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
  

• Du kan anropa en static (Shared i Visual Basic) BigInteger metod som utför en viss åtgärd i ett numeriskt uttryck och returnerar ett beräknat BigInteger resultat. Följande exempel gör detta genom att upphöja UInt64.MaxValue till tredje potensen och tilldela resultatet till en 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
  

Det o-initialiserade värdet för en BigInteger är Zero.

Utföra åtgärder på BigInteger-värden

Du kan använda en BigInteger-instans precis som du skulle använda en annan integraltyp. BigInteger överbelastar de numeriska standardoperatorerna så att du kan utföra grundläggande matematiska åtgärder som addition, subtraktion, division, multiplikation och oharisk negation. Du kan också använda de numeriska standardoperatorerna för att jämföra två BigInteger värden med varandra. Liksom de andra integraltyperna stöder BigInteger även de bitvisa operatorerna för And, Or, XOr, vänsterskift och högerskift. För språk som inte stöder anpassade operatorer tillhandahåller BigInteger struktur även motsvarande metoder för att utföra matematiska operationer. Dessa inkluderar Add, Divide, Multiply, Negate, Subtractoch flera andra.

Många medlemmar i BigInteger struktur motsvarar direkt medlemmar av de andra integraltyperna. Dessutom lägger BigInteger till medlemmar, till exempel följande:

• Sign, som returnerar ett värde som anger tecknet för ett BigInteger värde.

• Abs, som returnerar det absoluta värdet för ett BigInteger värde.

• DivRem, som returnerar både kvoten och resten av en divisionsåtgärd.

• GreatestCommonDivisor, som returnerar den största gemensamma delaren av två BigInteger värden.

Många av dessa ytterligare medlemmar motsvarar medlemmarna i klassen Math, vilket ger funktioner för att arbeta med de primitiva numeriska typerna.

Föränderlighet

I följande exempel instansierar ett BigInteger objekt och ökar sedan dess värde med ett.

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)

Även om det här exemplet verkar ändra värdet för det befintliga objektet är detta inte fallet. BigInteger objekt är oföränderliga, vilket innebär att den gemensamma språkkörningen internt faktiskt skapar ett nytt BigInteger objekt och tilldelar det ett värde som är större än dess tidigare värde. Det nya objektet returneras sedan till anroparen.

Även om den här processen är transparent för anroparen medför den en prestandaavgift. I vissa fall, särskilt när upprepade åtgärder utförs i en loop på mycket stora BigInteger värden, kan prestandastraffet vara betydande. I följande exempel utförs till exempel en åtgärd repetitivt upp till en miljon gånger och ett BigInteger värde ökas med en varje gång åtgärden lyckas.

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

I så fall kan du förbättra prestanda genom att utföra alla mellanliggande tilldelningar till en Int32 variabel. Det slutliga värdet för variabeln kan sedan tilldelas till BigInteger-objektet när loopen avslutas. I följande exempel visas en bild.

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

Bytematriser och hexadecimala strängar

Om du konverterar BigInteger värden till bytematriser, eller om du konverterar bytematriser till BigInteger värden, måste du överväga byteordningen. Den BigInteger strukturen förväntar sig att de enskilda byteen i en bytematris ska visas i lite endiansk ordning (dvs. lägre orderbyte för värdet före byte med högre ordning). Du kan runda ett BigInteger-värde genom att anropa metoden ToByteArray och sedan skicka den resulterande byte-array till BigInteger(Byte[])-konstruktorn, som i följande exempel.

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

Om du vill instansiera ett BigInteger värde från en bytematris som representerar ett värde av någon annan integrerad typ kan du skicka integralvärdet till metoden BitConverter.GetBytes och sedan skicka den resulterande bytematrisen till BigInteger(Byte[]) konstruktorn. I följande exempel instansieras ett BigInteger värde från en bytematris som representerar ett Int16 värde.

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

Strukturen BigInteger förutsätter att negativa värden lagras med hjälp av tvåkomplementsrepresentation. Eftersom den BigInteger strukturen representerar ett numeriskt värde utan fast längd tolkar BigInteger(Byte[]) konstruktorn alltid den viktigaste biten av den sista byteen i matrisen som en teckenbit. För att förhindra att BigInteger(Byte[])-konstruktorn förväxlar tvåkomplementrepresentationen av ett negativt värde med tecken- och storleksrepresentationen av ett positivt värde, bör positiva värden där den mest signifikanta biten i den sista byten i byte-arrayen kan vara satt innehålla en ytterligare byte vars värde är 0. Till exempel är 0xC0 0xBD 0xF0 0xFF den lilla hexadecimala representationen av antingen -1 000 000 eller 4 293 967 296. Eftersom den viktigaste biten av den sista byte i den här matrisen är på tolkas värdet för bytematrisen av BigInteger(Byte[]) konstruktorn som -1 000 000. Om du vill instansiera en BigInteger vars värde är positivt måste en bytematris vars element 0xC0 0xBD 0xF0 0xFF 0x00 skickas till konstruktorn. I följande exempel visas detta.

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

Bytematriser som skapats av metoden ToByteArray från positiva värden inkluderar detta extra nollvärdesbyte. Därför kan BigInteger-strukturen framgångsrikt överföra värden genom att tilldela dem till och sedan återställa dem från bytefält, vilket visas i följande exempel.

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

Du kan dock behöva lägga till denna ytterligare nollvärdesbyte till bytematriser som skapas dynamiskt av utvecklaren eller som returneras av metoder som konverterar osignerade heltal till bytematriser (till exempel BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)och BitConverter.GetBytes(UInt64)).

När du parsar en hexadecimal sträng förutsätter metoderna BigInteger.Parse(String, NumberStyles) och BigInteger.Parse(String, NumberStyles, IFormatProvider) att om den viktigaste biten av den första byteen i strängen anges, eller om den första hexadecimala siffran i strängen representerar de lägre fyra bitarna av ett bytevärde, representeras värdet med hjälp av tvås komplementrepresentation. Till exempel representerar både "FF01" och "F01" decimalvärdet -255. För att särskilja positiva värden från negativa värden bör positiva värden innehålla en inledande nolla. Relevanta överbelastningar av metoden ToString, när de får formatsträngen "X", lägger till en följande nolla till den returnerade hexadecimala strängen för positiva värden. Detta gör det möjligt att överföra BigInteger-värden fram och tillbaka med hjälp av metoderna ToString och Parse, som visas i följande exempel.

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 hexadecimala strängar som skapas genom att anropa de ToString metoderna för de andra integraltyperna eller överlagringarna av metoden ToString som innehåller en toBase parameter anger dock inte tecknet på värdet eller källdatatypen som hexadecimal strängen härleddes från. För att framgångsrikt skapa en instans av ett BigInteger-värde från en sådan sträng krävs ytterligare logik. I följande exempel finns en möjlig implementering.

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.