System.Numerics.BigInteger yapısı

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

Tür BigInteger , teorideki değerin üst veya alt sınırları olmayan rastgele büyük bir tamsayıyı temsil eden sabit bir türdür. Türün BigInteger üyeleri, diğer integral türlerine ( Byte, , Int16, Int32, Int64, SByte, UInt16, UInt32ve UInt64 türleri) yakın paraleldir. Bu tür, ve özellikleriyle belirtilen bir aralığa sahip olan .NET'teki diğer tam sayı türlerinden MinValueMaxValue farklıdır.

Not

BigInteger Tür sabit olduğundan (bkz. Mutability) ve üst veya alt sınırları olmadığından, OutOfMemoryException değerin çok büyük olmasına neden olan herhangi bir işlem için bir BigInteger oluşturulabilir.

BigInteger nesnesinin örneğini oluşturma

Bir BigInteger nesnenin örneğini çeşitli yollarla oluşturabilirsiniz:

• anahtar sözcüğünü kullanabilir ve oluşturucuya new parametre olarak tüm integral veya kayan BigInteger nokta değerlerini sağlayabilirsiniz. (Kayan nokta değerleri öğesine atanmadan BigIntegerönce kesilir.) Aşağıdaki örnekte, değerlerin BigInteger örneğini oluştururken anahtar sözcüğün new nasıl kullanılacağı gösterilmektedir.

  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
  

• Bir değişken bildirebilir BigInteger ve bu değer tam sayı türünde olduğu sürece herhangi bir sayısal türde yaptığınız gibi bir değer atayabilirsiniz. Aşağıdaki örnek, atamayı kullanarak bir Int64değerinden bir BigInteger değer oluşturur.

  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
  

• Değeri atarsanız veya önce dönüştürürseniz nesneye BigInteger ondalık veya kayan nokta değeri atayabilirsiniz. Aşağıdaki örnek açıkça (C#'de) veya (Visual Basic'te) ve DoubleDecimal değerini BigIntegerdeğerine dönüştürür.

  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
  

Bu yöntemler, değeri yalnızca mevcut sayısal türlerden birinin aralığında olan bir BigInteger nesnenin örneğini oluşturmanızı sağlar. Değeri mevcut sayısal türlerin aralığını aşabilen bir BigInteger nesnenin örneğini üç yoldan biriyle oluşturabilirsiniz:

• anahtar sözcüğünü new kullanabilir ve oluşturucuya BigInteger.BigInteger herhangi bir boyutta bayt dizisi sağlayabilirsiniz. Örneğin:

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

• Bir sayının Parse dize gösterimini öğesine dönüştürmek için BigIntegerveya TryParse yöntemlerini çağırabilirsiniz. Örneğin:

  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
  

• Bir sayısal ifade üzerinde bazı işlemler gerçekleştiren ve hesaplanan BigInteger sonuç döndüren bir (Shared Visual Basic'te) BigInteger yöntemini çağırabilirsiniz static . Aşağıdaki örnek bunu, sonucunu oluşturup UInt64.MaxValue öğesine BigIntegeratayarak yapar.

  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
  

öğesinin BigInteger başlatılmamış değeridir Zero.

BigInteger değerlerinde işlem gerçekleştirme

Başka bir tamser türünü kullandığınız gibi bir BigInteger örneği kullanabilirsiniz. BigInteger toplama, çıkarma, bölme, çarpma ve tekli olumsuzlama gibi temel matematiksel işlemleri gerçekleştirmenizi sağlamak için standart sayısal işleçleri aşırı yükler. İki değeri birbiriyle karşılaştırmak BigInteger için standart sayısal işleçleri de kullanabilirsiniz. Diğer integral türleri gibi bit BigInteger düzeyinde And, , Or, XOrsol shift ve sağ shift işleçlerini de destekler. Özel işleçleri desteklemeyen diller için yapı, BigInteger matematiksel işlemleri gerçekleştirmek için eşdeğer yöntemler de sağlar. Bunlar , , Divide, MultiplyNegate, , Subtractve diğerleridirAdd.

Yapının birçok üyesi BigInteger , diğer integral türlerinin üyelerine doğrudan karşılık gelir. Buna ek olarak, BigInteger aşağıdakiler gibi üyeler ekler:

• Sign, bir değerin işaretini gösteren bir BigInteger değer döndürür.

• Abs, bir BigInteger değerin mutlak değerini döndürür.

• DivRem, bölme işleminin hem bölümünü hem de kalan bölümünü döndürür.

• GreatestCommonDivisor, iki BigInteger değerin en büyük ortak böleni döndürür.

Bu ek üyelerin çoğu, ilkel sayısal türlerle çalışma işlevselliği sağlayan sınıfın üyelerine Math karşılık gelir.

Mutability

Aşağıdaki örnek bir BigInteger nesnenin örneğini oluşturur ve ardından değerini bir artırır.

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)

Bu örnek, mevcut nesnenin değerini değiştirmek için görünse de, bu durum geçerli değildir. BigInteger nesneler sabittir, yani dahili olarak ortak dil çalışma zamanı aslında yeni BigInteger bir nesne oluşturur ve önceki değerinden bir daha büyük bir değer atar. Bu yeni nesne daha sonra çağırana döndürülür.

Not

.NET'teki diğer sayısal türler de sabittir. Ancak, türün BigInteger üst veya alt sınırları olmadığından değerleri son derece büyüyebilir ve performans üzerinde ölçülebilir bir etkiye sahip olabilir.

Bu işlem çağıran için saydam olsa da, bir performans cezasına neden olur. Bazı durumlarda, özellikle çok büyük BigInteger değerler üzerinde bir döngüde yinelenen işlemler gerçekleştirildiğinde, bu performans cezası önemli olabilir. Örneğin, aşağıdaki örnekte bir işlem tekrar tekrar bir milyon kez gerçekleştirilir ve işlem her başarılı olduğunda bir BigInteger değer bir artırılır.

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

Böyle bir durumda, bir Int32 değişkene tüm ara atamaları gerçekleştirerek performansı geliştirebilirsiniz. Döngüden çıkıldığında değişkenin son değeri nesneye BigInteger atanabilir. Aşağıdaki örnek, bir gösterim sağlar.

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

Bayt dizileri ve onaltılık dizeler

Değerleri bayt dizilerine dönüştürürseniz BigInteger veya bayt dizilerini değerlere BigInteger dönüştürürseniz bayt sırasını dikkate almanız gerekir. Yapı, BigInteger bayt dizisindeki tek tek baytların küçük endian sırada görünmesini bekler (yani, değerin alt sıralı baytları daha yüksek sıralı baytlardan önce gelir). Aşağıdaki örnekte gösterildiği gibi, yöntemini çağırıp ToByteArray sonuçta elde edilen bayt dizisini oluşturucuya BigInteger(Byte[]) geçirerek bir BigInteger değeri gidiş dönüş yapabilirsiniz.

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

Başka bir BigInteger integral türünün değerini temsil eden bir bayt dizisinden bir değer örneği oluşturmak için, integral değerini yöntemine BitConverter.GetBytes geçirebilir ve ardından sonuçta elde edilen bayt dizisini oluşturucuya BigInteger(Byte[]) geçirebilirsiniz. Aşağıdaki örnek, bir BigInteger değeri temsil eden bayt dizisinden bir değerin örneğini Int16 oluşturur.

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

Yapısı, BigInteger negatif değerlerin ikinin tamamlayıcı gösterimi kullanılarak depolandığını varsayar. BigInteger Yapı sabit uzunluğu olmayan bir sayısal değeri temsil ettiğindenBigInteger(Byte[]), oluşturucu her zaman dizideki son baytın en önemli bitini işaret biti olarak yorumlar. Oluşturucunun BigInteger(Byte[]) negatif değerin iki tamamlayıcı gösterimini pozitif bir değerin işareti ve büyüklük gösterimiyle karıştırmasını önlemek için, bayt dizisindeki son baytın en önemli bitinin normalde ayarlanacağı pozitif değerler, değeri 0 olan ek bir bayt içermelidir. Örneğin, 0xC0 0xBD 0xF0 0xFF -1.000.000 veya 4.293.967.296'nın küçük ender onaltılık gösterimidir. Bu dizideki son baytın en önemli biti açık olduğundan, bayt dizisinin değeri oluşturucu tarafından BigInteger(Byte[]) -1.000.000 olarak yorumlanır. Değeri pozitif olan bir BigInteger örneği oluşturmak için öğeleri 0xC0 0xBD 0xF0 0xFF 0x00 olan bir bayt dizisi oluşturucuya geçirilmelidir. Aşağıdaki örnek bunu göstermektedir.

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

Yöntemi tarafından ToByteArray pozitif değerlerden oluşturulan bayt dizileri bu fazladan sıfır değerli bayt içerir. Bu nedenle, aşağıdaki örnekte gösterildiği gibi yapı BigInteger , değerleri 'a atayarak ve sonra bayt dizilerinden geri yükleyerek başarıyla gidiş dönüş yapabilir.

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

Ancak, geliştirici tarafından dinamik olarak oluşturulan veya imzalanmamış tamsayıları bayt dizilerine (, ve BitConverter.GetBytes(UInt64)gibiBitConverter.GetBytes(UInt16)BitConverter.GetBytes(UInt32)) dönüştüren yöntemler tarafından döndürülen bayt dizilerine bu ek sıfır değerli bayt eklemeniz gerekebilir.

Bir onaltılık dize ayrıştırılırken ve BigInteger.Parse(String, NumberStyles, IFormatProvider) yöntemleri, BigInteger.Parse(String, NumberStyles) dizedeki ilk baytın en önemli biti ayarlanırsa veya dizenin ilk onaltılık basamağı bir bayt değerinin düşük dört bitini temsil ederse, değerin ikinin tamamlayıcı gösterimi kullanılarak temsil edilir. Örneğin, hem "FF01" hem de "F01" ondalık değeri -255'i temsil eder. Pozitif değerleri negatif değerlerden ayırt etmek için pozitif değerler baştaki sıfırı içermelidir. Yöntemin ToString ilgili aşırı yüklemeleri, "X" biçim dizesi geçirildiğinde, pozitif değerler için döndürülen onaltılık dizeye bir baştaki sıfır ekler. Bu, aşağıdaki örnekte gösterildiği gibi ve Parse yöntemlerini kullanarak ToString gidiş dönüş BigInteger değerlerinin mümkün olmasını sağlar.

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.

Ancak, diğer integral türlerinin ToString yöntemlerini çağırarak oluşturulan onaltılık dizeler veya parametre toBase içeren yöntemin ToString aşırı yüklemeleri, değerin işaretini veya onaltılık dizenin türetildiği kaynak veri türünü göstermez. Böyle bir dizeden bir BigInteger değerin başarıyla örneğini oluşturmak için bazı ek mantık gerekir. Aşağıdaki örnek olası bir uygulama sağlar.

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.