System.Numerics.BigInteger, struktura

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

Typ BigInteger jest niezmiennym typem reprezentującym dowolnie dużą liczbę całkowitą, której wartość teoretycznie nie ma granic górnych ani dolnych. Elementy członkowskie BigInteger typu ściśle równoległe te z innych typów całkowitych (Bytetypy , , Int16, Int64Int32SByte, UInt16, UInt32, i UInt64 ). Ten typ różni się od innych typów całkowitych na platformie .NET, które mają zakres wskazywany przez ich MinValue właściwości i MaxValue .

Uwaga

BigInteger Ponieważ typ jest niezmienny (zobacz Mutability) i ponieważ nie ma granic górnej lub dolnej, można zgłosić dla każdej operacji, OutOfMemoryException która powoduje BigInteger zwiększenie zbyt dużej wartości.

Tworzenie wystąpienia obiektu BigInteger

Wystąpienie obiektu można utworzyć BigInteger na kilka sposobów:

• Możesz użyć słowa kluczowego new i podać dowolną wartość całkowitą lub zmiennoprzecinkową jako parametr konstruktora BigInteger . (Wartości zmiennoprzecinkowe są obcinane, zanim zostaną przypisane do . BigInteger W poniższym przykładzie pokazano, jak używać słowa kluczowego new do tworzenia wystąpień BigInteger wartości.

  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
  

• Można zadeklarować zmienną BigInteger i przypisać jej wartość tak samo jak dowolny typ liczbowy, o ile ta wartość jest typem całkowitym. W poniższym przykładzie użyto przypisania w celu utworzenia BigInteger wartości na podstawie elementu 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
  

• Można przypisać wartość dziesiętną lub zmiennoprzecinkową do BigInteger obiektu, jeśli najpierw rzutujesz wartość lub konwertujesz ją jako pierwszą. Poniższy przykład jawnie rzutuje (w języku C#) lub konwertuje (w Visual Basic) Double wartość i Decimal na BigIntegerwartość .

  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
  

Te metody umożliwiają utworzenie wystąpienia BigInteger obiektu, którego wartość znajduje się tylko w zakresie jednego z istniejących typów liczbowych. Można utworzyć BigInteger wystąpienie obiektu, którego wartość może przekroczyć zakres istniejących typów liczbowych na jeden z trzech sposobów:

• Możesz użyć słowa kluczowego new i podać tablicę bajtów dowolnego rozmiaru konstruktora BigInteger.BigInteger . Na przykład:

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

• Metody lub TryParse można wywołaćParse, aby przekonwertować reprezentację BigIntegerciągu liczby na . Na przykład:

  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
  

• Można wywołać metodę static (Shared w Visual Basic), BigInteger która wykonuje jakąś operację na wyrażeniu liczbowym i zwraca wynik obliczeniowy BigInteger . W poniższym przykładzie można to zrobić, buforując i przypisując UInt64.MaxValue wynik do obiektu 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
  

Niezainicjowana wartość elementu BigInteger to Zero.

Wykonywanie operacji na wartościach BigInteger

Możesz użyć BigInteger wystąpienia, tak jak w przypadku dowolnego innego typu całkowitego. BigInteger przeciąża standardowe operatory liczbowe, aby umożliwić wykonywanie podstawowych operacji matematycznych, takich jak dodawanie, odejmowanie, dzielenie, mnożenie i negacja jednoargumentowa. Można również użyć standardowych operatorów liczbowych, aby porównać dwie BigInteger wartości ze sobą. Podobnie jak w przypadku innych typów całkowitych, BigInteger obsługuje również operatory bitowe And, , Or, XOrshift w lewo i w prawo. W przypadku języków, które nie obsługują operatorów niestandardowych, BigInteger struktura udostępnia również równoważne metody wykonywania operacji matematycznych. Należą do nichAdd: , , NegateDivideMultiply, , Subtracti kilka innych.

Wiele elementów członkowskich BigInteger struktury odpowiada bezpośrednio członkom innych typów całkowitych. Ponadto dodaje członków, BigInteger takich jak następujące:

• Sign, która zwraca wartość wskazującą znak BigInteger wartości.

• Abs, która zwraca wartość bezwzględną BigInteger wartości.

• DivRem, który zwraca zarówno iloraz i pozostałą część operacji dzielenia.

• GreatestCommonDivisor, który zwraca największy wspólny dzielnika dwóch BigInteger wartości.

Wiele z tych dodatkowych składowych odpowiada członkom Math klasy, co zapewnia funkcjonalność pracy z typami liczb pierwotnymi.

Możliwość mutowania

Poniższy przykład tworzy wystąpienie BigInteger obiektu, a następnie zwiększa jego wartość o jedną.

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)

Mimo że ten przykład wydaje się modyfikować wartość istniejącego obiektu, nie jest tak. BigInteger obiekty są niezmienne, co oznacza, że wewnętrznie środowisko uruchomieniowe języka wspólnego tworzy nowy BigInteger obiekt i przypisuje mu wartość większą niż poprzednia wartość. Ten nowy obiekt zostanie następnie zwrócony do obiektu wywołującego.

Uwaga

Inne typy liczbowe na platformie .NET są również niezmienne. Jednak ze względu na to BigInteger , że typ nie ma granic górnych lub dolnych, jego wartości mogą rosnąć bardzo duże i mieć wymierny wpływ na wydajność.

Mimo że ten proces jest niewidoczny dla elementu wywołującego, wiąże się z karą za wydajność. W niektórych przypadkach, zwłaszcza gdy powtarzające się operacje są wykonywane w pętli na bardzo dużych BigInteger wartościach, kara za wydajność może być znacząca. Na przykład w poniższym przykładzie operacja jest wykonywana powtarzalnie do miliona razy, a BigInteger wartość jest zwiększana o jeden za każdym razem, gdy operacja zakończy się pomyślnie.

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

W takim przypadku można zwiększyć wydajność, wykonując wszystkie przypisania pośrednie do zmiennej Int32 . Ostateczna wartość zmiennej można następnie przypisać do obiektu po zakończeniu BigInteger pętli. Poniższy przykład stanowi ilustrację.

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

Tablice bajtowe i ciągi szesnastkowe

W przypadku konwertowania BigInteger wartości na tablice bajtów lub konwersji tablic bajtowych na BigInteger wartości należy wziąć pod uwagę kolejność bajtów. Struktura BigInteger oczekuje, że poszczególne bajty w tablicy bajtów pojawią się w małej kolejności endian (czyli bajty niższej kolejności wartości poprzedzają bajty wyższego rzędu). Wartość można zaokrąglić, wywołując ToByteArray metodę BigInteger , a następnie przekazując wynikową tablicę bajtów do konstruktoraBigInteger(Byte[]), jak pokazano w poniższym przykładzie.

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

Aby utworzyć BigInteger wystąpienie wartości z tablicy bajtów, która reprezentuje wartość innego typu całkowitego, można przekazać wartość całkowitą do BitConverter.GetBytes metody, a następnie przekazać wynikową tablicę bajtów do konstruktora BigInteger(Byte[]) . Poniższy przykład tworzy wystąpienie BigInteger wartości z tablicy bajtów, która reprezentuje Int16 wartość.

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 zakłada, że wartości ujemne są przechowywane przy użyciu reprezentacji uzupełniającej dwóch. BigInteger Ponieważ struktura reprezentuje wartość liczbową bez stałej długości, BigInteger(Byte[]) konstruktor zawsze interpretuje najbardziej znaczący bit ostatniego bajtu w tablicy jako bit znaku. Aby uniemożliwić BigInteger(Byte[]) konstruktorowi mylące reprezentację wartości ujemnej z reprezentacją znaku i wielkości wartości dodatniej, wartości dodatnie, w których najbardziej znaczący bit ostatniego bajtu w tablicy bajtów bajtów zwykle powinien zawierać dodatkowy bajt, którego wartość wynosi 0. Na przykład 0xC0 0xBD 0xF0 0xFF jest mało endianową reprezentacją szesnastkowa -1000 000 lub 4 293 967 2966. Ponieważ najbardziej znaczący bit ostatniego bajtu w tej tablicy jest włączony, wartość tablicy bajtów będzie interpretowana przez BigInteger(Byte[]) konstruktora jako -1000 000. Aby utworzyć BigInteger wystąpienie, którego wartość jest dodatnia, tablica bajtów, której elementy są 0xC0 0xBD 0xF0 0xFF 0x00 musi zostać przekazana do konstruktora. Ilustruje to poniższy przykład.

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

Tablice bajtów utworzone przez metodę ToByteArray z wartości dodatnich obejmują ten dodatkowy bajt zerowej wartości. W związku z tym struktura może pomyślnie zaokrąglić wartości, BigInteger przypisując je do, a następnie przywracając je z tablic bajtowych, jak pokazano w poniższym przykładzie.

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

Może jednak być konieczne dodanie tego dodatkowego bajtu o wartości zerowej do tablic bajtów tworzonych dynamicznie przez dewelopera lub zwracanych przez metody, które konwertują niepodpisane liczby całkowite na tablice bajtów (takie jak BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)i BitConverter.GetBytes(UInt64)).

Podczas analizowania ciągu szesnastkowego metody i BigInteger.Parse(String, NumberStyles, IFormatProvider) zakładają, BigInteger.Parse(String, NumberStyles) że jeśli najbardziej znaczący bit pierwszego bajtu w ciągu jest ustawiony, lub jeśli pierwsza cyfra szesnastkowa ciągu reprezentuje dolne cztery bity wartości bajtowej, wartość jest reprezentowana przy użyciu reprezentacji uzupełniającej dwóch. Na przykład wartości "FF01" i "F01" reprezentują wartość dziesiętną -255. Aby odróżnić wartości dodatnie od wartości ujemnych, wartości dodatnie powinny zawierać zero wiodące. Odpowiednie przeciążenia ToString metody, gdy są przekazywane ciąg formatu "X", dodaj wiodące zero do zwracanego ciągu szesnastkowego dla wartości dodatnich. Dzięki temu można zaokrąglić BigInteger wartości przy użyciu ToString metod i Parse , jak pokazano w poniższym przykładzie.

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.

Jednak ciągi szesnastkowe utworzone przez wywołanie ToString metod innych typów całkowitych lub przeciążeń ToString metody zawierającej toBase parametr nie wskazują znaku wartości lub typu danych źródłowych, z którego pochodzi ciąg szesnastkowy. Pomyślne utworzenie wystąpienia BigInteger wartości z takiego ciągu wymaga dodatkowej logiki. Poniższy przykład przedstawia jedną z możliwych implementacji.

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.