System.Numerics.BigInteger – struktura

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Typ BigInteger je neměnný typ, který představuje libovolné velké celé číslo, jehož hodnota teoreticky nemá žádné horní nebo dolní hranice. Členové BigInteger typu úzce paralelně paralelně s jinými integrálními typy (the Byte, Int16, Int32, Int64, SByte, UInt16UInt32) a UInt64 typy). Tento typ se liší od ostatních integrálních typů v .NET, které mají rozsah označený jejich MinValue vlastnostmi a MaxValue vlastnostmi.

Poznámka:

BigInteger Vzhledem k tomu, že typ je neměnný (viz Mutability) a protože nemá žádné horní nebo dolní hranice, OutOfMemoryException může být vyvolán pro jakoukoli operaci, která způsobíBigInteger, že hodnota bude příliš velká.

Vytvoření instance objektu BigInteger

Vytvoření instance objektu BigInteger několika způsoby:

• Klíčové slovo můžete použít new a jako parametr konstruktoru zadat jakoukoli celočíselnou hodnotu nebo hodnotu s plovoucí desetinou čárkou BigInteger . (Hodnoty s plovoucí desetinou čárkou jsou zkráceny před jejich přiřazením k hodnotě BigInteger.) Následující příklad ukazuje, jak pomocí klíčového new slova vytvořit instanci BigInteger hodnot.

  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
  

• Proměnnou BigInteger můžete deklarovat a přiřadit ji stejně jako jakýkoli číselný typ, pokud je tato hodnota celočíselným typem. Následující příklad používá přiřazení k vytvoření BigInteger hodnoty z objektu 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
  

• Pokud hodnotu přetypujete nebo převedete jako první, můžete objektu přiřadit desetinnou nebo plovoucí desetinnou čárku BigInteger . Následující příklad explicitně přetypuje (v jazyce C#) nebo převede (v jazyce Visual Basic) Double a hodnotu Decimal na 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
  

Tyto metody umožňují vytvořit instanci objektu BigInteger , jehož hodnota je v rozsahu jednoho z existujících číselných typů. Můžete vytvořit instanci objektu BigInteger , jehož hodnota může překročit rozsah existujících číselných typů jedním ze tří způsobů:

• Klíčové slovo můžete použít new a poskytnout bajt pole libovolné velikosti konstruktoru BigInteger.BigInteger . Příklad:

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

• Můžete volat Parse nebo TryParse metody pro převod řetězcové reprezentace čísla na .BigInteger Příklad:

  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
  

• Můžete volat metodu static (Shared v jazyce Visual Basic), BigInteger která provádí určitou operaci s číselným výrazem a vrací počítaný BigInteger výsledek. Následující příklad to provede cubing UInt64.MaxValue a přiřazení výsledku k .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
  

Neinicializovaná hodnota je BigIntegerZero.

Provádění operací s hodnotami BigInteger

Instanci můžete použít BigInteger stejně jako jakýkoli jiný celočíselný typ. BigInteger přetěžuje standardní číselné operátory, které umožňují provádět základní matematické operace, jako jsou sčítání, odčítání, dělení, násobení a unární negace. Standardní číselné operátory můžete použít také k porovnání dvou BigInteger hodnot mezi sebou. Stejně jako ostatní integrální typy podporuje BigInteger také bitové And, Or, , XOrlevý posun a operátory pravého posunu. U jazyků, které nepodporují vlastní operátory, BigInteger poskytuje struktura také ekvivalentní metody pro provádění matematických operací. Patří mezi ně Add, , NegateDivideMultiply, , Subtracta několik dalších.

Mnoho členů BigInteger struktury přímo odpovídá členům ostatních integrálních typů. Kromě toho přidá členy, BigInteger například:

• Sign, která vrátí hodnotu, která označuje znaménko BigInteger hodnoty.

• Abs, který vrátí absolutní hodnotu BigInteger hodnoty.

• DivRem, který vrátí podíl i zbytek operace dělení.

• GreatestCommonDivisor, který vrátí největší společný dělitel dvou BigInteger hodnot.

Mnoho z těchto dalších členů odpovídá členům Math třídy, což poskytuje funkce pro práci s primitivními číselnými typy.

Mutability

Následující příklad vytvoří instanci objektu BigInteger a potom zvýší jeho hodnotu o jednu.

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)

I když se tento příklad jeví jako změna hodnoty existujícího objektu, nejedná se o případ. BigInteger objekty jsou neměnné, což znamená, že modul CLR (Common Language Runtime) ve skutečnosti vytvoří nový BigInteger objekt a přiřadí mu hodnotu větší než předchozí hodnota. Tento nový objekt se pak vrátí volajícímu.

Poznámka:

Ostatní číselné typy v .NET jsou také neměnné. Vzhledem k tomu, že BigInteger typ nemá žádné horní nebo dolní hranice, mohou jeho hodnoty růst extrémně velké a mají měřitelný dopad na výkon.

I když je tento proces pro volajícího transparentní, způsobuje to snížení výkonu. V některých případech, zejména pokud jsou opakované operace prováděny ve smyčce s velmi velkými BigInteger hodnotami, může být snížení výkonu významné. Například v následujícím příkladu se operace provádí opakovaně až milionkrát a BigInteger při každém úspěšném dokončení operace se zvýší o jednu hodnotu.

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

V takovém případě můžete zvýšit výkon provedením všech přechodných přiřazení k Int32 proměnné. Konečná hodnota proměnné se pak může přiřadit k objektu BigInteger , když smyčka skončí. V následujícím příkladu je uvedena ukázka.

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

Bajtová pole a šestnáctkové řetězce

Při převodu BigInteger hodnot na bajtová pole nebo při převodu bajtů na BigInteger hodnoty je nutné zvážit pořadí bajtů. Struktura BigInteger očekává, že se jednotlivé bajty v bajtovém poli zobrazí v malém endovém pořadí (tj. bajty nižšího pořadí hodnoty před bajty vyššího řádu). Hodnotu můžete zaokrouhlit BigInteger voláním ToByteArray metody a následným předáním výsledného bajtového pole do konstruktoru BigInteger(Byte[]) , jak ukazuje následující příklad.

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

Chcete-li vytvořit BigInteger instanci hodnoty z bajtového pole představující hodnotu jiného celočíselného typu, můžete předat celočíselnou hodnotu BitConverter.GetBytes metodě a pak předat výsledné bajtové pole konstruktoru BigInteger(Byte[]) . Následující příklad vytvoří BigInteger instanci hodnoty z bajtového pole, které představuje Int16 hodnotu.

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

Struktura BigInteger předpokládá, že záporné hodnoty jsou uloženy pomocí reprezentace doplňku dvou. Vzhledem k tomu, že BigInteger struktura představuje číselnou hodnotu bez pevné délky, BigInteger(Byte[]) konstruktor vždy interpretuje nejvýznamnější bit posledního bajtu v poli jako bit znaménka. Chcete-li konstruktoru zabránit BigInteger(Byte[]) matoucím reprezentaci záporné hodnoty se znaménkem a velikostí kladné hodnoty, kladné hodnoty, ve kterých by byl obvykle nastaven nejvýznamnější bit posledního bajtu v bajtovém poli, by měl být obvykle nastaven další bajt, jehož hodnota je 0. Například 0xC0 0xBD 0xF0 0xFF je malé šestnáctkové vyjádření -1 000 000 nebo 4 293 967 296. Vzhledem k tomu, že nejvýznamnější bit posledního bajtu v tomto poli je zapnutý, bude hodnota bajtového pole interpretována konstruktorem BigInteger(Byte[]) jako -1 000 000. Chcete-li vytvořit BigInteger instanci hodnoty, jejíž hodnota je kladná, musí být do konstruktoru předána pole bajtů, jehož prvky jsou 0xC0 0xBD 0xF0 0xFF 0x00. Toto dokládá následující příklad.

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

Bajtová pole vytvořená metodou ToByteArray z kladných hodnot zahrnují tento dodatečný bajt nulové hodnoty. BigInteger Proto může struktura úspěšně zaokrouhlit hodnoty jejich přiřazením a následným obnovením z polí bajtů, jak ukazuje následující příklad.

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

Tento dodatečný bajt nulové hodnoty však může být potřeba přidat k bajtovým polím vytvořeným dynamicky vývojářem nebo vrácené metodami, které převádějí celá čísla bez znaménka na bajtová pole (například BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)a BitConverter.GetBytes(UInt64)).

Při analýze šestnáctkového řetězce a BigInteger.Parse(String, NumberStyles, IFormatProvider) metody předpokládají, BigInteger.Parse(String, NumberStyles) že pokud je nastaven nejvýznamnější bit prvního bajtu v řetězci, nebo pokud první šestnáctková číslice řetězce představuje nižší čtyři bity bajtové hodnoty, je hodnota reprezentována pomocí dvou doplňkových reprezentací. Například "FF01" i "F01" představují desetinnou hodnotu -255. Aby bylo možné odlišit kladné hodnoty od záporných hodnot, měly by kladné hodnoty obsahovat úvodní nulu. Relevantní přetížení ToString metody, když jsou předány "X" formát řetězec, přidejte úvodní nulu vrácený šestnáctkový řetězec pro kladné hodnoty. To umožňuje hodnoty odezvy BigInteger pomocí ToString metod a Parse metod, jak ukazuje následující příklad.

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.

Hexadecimální řetězce vytvořené voláním ToString metod jiných integrálních typů nebo přetížení ToString metody, které obsahují toBase parametr, neznačí znaménko hodnoty nebo zdrojového datového typu, ze kterého byl šestnáctkový řetězec odvozen. Úspěšné vytvoření instance BigInteger hodnoty z takového řetězce vyžaduje další logiku. Následující příklad poskytuje jednu možnou implementaci.

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