BigInteger Oluşturucular

Tanım

Ad Alanı:

System.Numerics

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.Numerics.dll

Yapının yeni bir örneğini BigInteger başlatır.

Aşırı Yüklemeler

Name	Description
BigInteger(Byte[])	Bayt dizisindeki BigInteger değerleri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(Decimal)	Bir değer kullanarak yapının yeni bir BigInteger örneğini Decimal başlatır.
BigInteger(Double)	Çift duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(Int32)	32 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(Int64)	64 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(Single)	Tek duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(UInt32)	İmzasız bir 32 bit tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(UInt64)	İmzasız bir 64 bit tamsayı değeriyle yapının yeni bir örneğini BigInteger başlatır.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Salt okunur bayt aralığındaki değerleri kullanarak ve isteğe bağlı olarak imzalama kodlamasını ve bitiş bayt sırasını gösteren yeni bir yapı örneği BigInteger başlatır.

BigInteger(Byte[])

Kaynak:

BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

Bayt dizisindeki BigInteger değerleri kullanarak yapının yeni bir örneğini başlatır.

public:
 BigInteger(cli::array <System::Byte> ^ value);

[System.CLSCompliant(false)]
public BigInteger(byte[] value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger

Public Sub New (value As Byte())

Parametreler

value

Byte[]

Küçük endian sırada bayt değerleri dizisi.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

ArgumentNullException

value, null'e eşittir.

Örnekler

Aşağıdaki örnek, değeri {5, 4, 3, 2, 1} olan 5 öğeli bayt dizisinden bir BigInteger nesne örneği oluşturur. Ardından konsolda BigInteger hem ondalık hem de onaltılık sayılar olarak gösterilen değeri görüntüler. Giriş dizisinin metin çıkışıyla karşılaştırılması, sınıf oluşturucusunun bu aşırı yüklemesinin BigInteger neden değeri 4328719365 (veya 0x102030405) olan bir BigInteger nesne oluşturduğunu netleştirir. Değeri 5 olan bayt dizisinin ilk öğesi, nesnenin 0x05 olan en düşük sıralı bayt değerini BigInteger tanımlar. Değeri 4 olan bayt dizisinin ikinci öğesi, nesnenin ikinci bayt BigInteger değerini (0x04 vb.) tanımlar.

byte[] bytes = { 5, 4, 3, 2, 1 };
BigInteger number = new BigInteger(bytes);
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number);
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

let bytes = [| 5uy; 4uy; 3uy; 2uy; 1uy |]
let number = new BigInteger(bytes)
printfn $"The value of number is {number} (or 0x{number:x})."
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).

Dim bytes() As Byte = { 5, 4, 3, 2, 1 }
Dim number As New BigInteger(bytes)
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number) 
' The example displays the following output:
'    The value of number is 4328719365 (or 0x102030405).

Aşağıdaki örnek pozitif ve negatif BigInteger bir değerin örneğini oluşturur, bunları yöntemine ToByteArray geçirir ve ardından elde edilen bayt dizisinden özgün BigInteger değerleri geri yükler. İki değerin aynı bayt dizileriyle temsil edilir. Aralarındaki tek fark, bayt dizisindeki son öğenin en önemli bitindedir. Dizi negatif BigInteger bir değerden oluşturulduysa bu bit ayarlanır (bayt değeri 0xFF). Dizi pozitif BigInteger bir değerden oluşturulduysa bit ayarlanmaz (bayt değeri sıfırdır).

// Instantiate BigInteger values.
BigInteger positiveValue = BigInteger.Parse("4713143110832790377889");
BigInteger negativeValue = BigInteger.Add(-Int64.MaxValue, -60000);
BigInteger positiveValue2, negativeValue2;

// Create two byte arrays.
byte[] positiveBytes = positiveValue.ToByteArray();
byte[] negativeBytes = negativeValue.ToByteArray();

// Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue);
foreach (byte byteValue in negativeBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue2 = new BigInteger(negativeBytes);
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2);
Console.WriteLine();

// Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue);
foreach (byte byteValue in positiveBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue2 = new BigInteger(positiveBytes);
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2);
Console.WriteLine();
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

// Instantiate BigInteger values.
let positiveValue = BigInteger.Parse "4713143110832790377889"
let negativeValue = BigInteger.Add(-Int64.MaxValue, -60000)

// Create two byte arrays.
let positiveBytes = positiveValue.ToByteArray()
let negativeBytes = negativeValue.ToByteArray()

// Instantiate new BigInteger from negativeBytes array.
printf $"Converted {negativeValue:N0} to the byte array "

for byteValue in negativeBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let negativeValue2 = bigint negativeBytes
printfn $"Converted the byte array to {negativeValue2:N0}"
printfn ""

// Instantiate new BigInteger from positiveBytes array.
printf $"Converted {positiveValue:N0} to the byte array "

for byteValue in positiveBytes do
    printf $"0x{byteValue:x2} "

printfn ""
let positiveValue2 = new BigInteger(positiveBytes)
printfn $"Converted the byte array to {positiveValue2:N0}"
printfn ""
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889

' Instantiate BigInteger values.
Dim positiveValue As BigInteger = BigInteger.Parse("4713143110832790377889")
Dim negativeValue As BigInteger = BigInteger.Add(-Int64.MaxValue, -60000) 
Dim positiveValue2, negativeValue2 As BigInteger

' Create two byte arrays.
Dim positiveBytes() As Byte = positiveValue.ToByteArray()
Dim negativeBytes() As Byte = negativeValue.ToByteArray()

' Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue)
For Each byteValue As Byte In negativeBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
negativeValue2 = New BigInteger(negativeBytes)
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2)
Console.WriteLine()

' Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue)
For Each byteValue As Byte In positiveBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
positiveValue2 = New BigInteger(positiveBytes)
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2)
Console.WriteLine()
' The example displays the following output:
'    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
'    Converted the byte array to -9,223,372,036,854,835,807
'    
'    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
'    Converted the byte array to 4,713,143,110,832,790,377,889

Aşağıdaki örnek, değeri dizinin sonuna sıfır olan bir bayt ekleyerek pozitif bir değerin hatalı bir şekilde negatif değer olarak örneklenmemesini sağlamayı gösterir.

ulong originalNumber = UInt64.MaxValue;
byte[] bytes = BitConverter.GetBytes(originalNumber);
if (originalNumber > 0 && (bytes[bytes.Length - 1] & 0x80) > 0)
{
   byte[] temp = new byte[bytes.Length];
   Array.Copy(bytes, temp, bytes.Length);
   bytes = new byte[temp.Length + 1];
   Array.Copy(temp, bytes, temp.Length);
}

BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.",
                  originalNumber, newNumber);
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

let originalNumber = UInt64.MaxValue
let mutable bytes = BitConverter.GetBytes originalNumber

if originalNumber > 0uL && (bytes[bytes.Length - 1] &&& 0x80uy) > 0uy then
    let temp = Array.zeroCreate bytes.Length

    Array.Copy(bytes, temp, bytes.Length)
    bytes <- Array.zeroCreate (temp.Length + 1)
    Array.Copy(temp, bytes, temp.Length)

let newNumber = bigint bytes
printfn $"Converted the UInt64 value {originalNumber:N0} to {newNumber:N0}."
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Dim originalNumber As ULong = UInt64.MaxValue
' Convert an unsigned integer to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalNumber)
' Determine whether the MSB of the highest-order byte is set.
If originalNumber > 0 And (bytes(bytes.Length - 1) And &h80) > 0 Then
   ' If the MSB is set, add one zero-value byte to the end of the array.
   ReDim Preserve bytes(bytes.Length)
End If

Dim newNumber As New BigInteger(bytes)
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.", 
                  originalNumber, newNumber) 
' The example displays the following output:
'    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Açıklamalar

Dizideki value tek tek baytlar, en düşük sıralı bayttan en yüksek sıralı bayta kadar küçük endian sırada olmalıdır. Örneğin, 1.000.000.000.000.000 sayısal değeri aşağıdaki tabloda gösterildiği gibi gösterilir:

Temsil	Değer
Onaltılık dize	E8D4A51000
Bayt dizisi (önce en düşük dizin)	00 10 A5 D4 E8 00

Sayısal değerleri ve BigInteger.ToByteArraygibi BitConverter.GetBytes bayt dizilerine dönüştüren yöntemlerin çoğu, bayt dizilerini küçük endian sırada döndürür.

Oluşturucu bayt dizisindeki pozitif değerlerin işaret ve büyüklük gösterimini, negatif değerleri ise ikinin tamamlayıcı gösterimini kullanmasını bekler. Başka bir deyişle, içindeki en yüksek sıralı baytın value en yüksek sıralı biti ayarlanırsa, sonuçta elde edilen BigInteger değer negatif olur. Bayt dizisinin kaynağına bağlı olarak, bu pozitif bir değerin negatif değer olarak yanlış yorumlanmasına neden olabilir. Bayt dizileri genellikle aşağıdaki yollarla oluşturulur:

• BigInteger.ToByteArray yöntemini çağırarak. Bu yöntem, pozitif değerler için sıfır olarak ayarlanmış dizideki en yüksek sıralı bayt bitine sahip bir bayt dizisi döndürdüğünden, pozitif değeri negatif olarak yanlış yorumlama şansı yoktur. yöntemi tarafından oluşturulan değiştirilmemiş bayt dizileri oluşturucuya ToByteArrayBigInteger(Byte[]) geçirildiğinde her zaman başarılı bir şekilde gidiş dönüş.

• yöntemini çağırıp BitConverter.GetBytes parametre olarak imzalı bir tamsayı geçirerek. İmzalı tamsayılar hem işaret hem de büyüklük gösterimini ve ikisinin tamamlayıcı gösterimini işlediğinden, pozitif bir değeri negatif olarak yanlış yorumlama şansı yoktur.

• yöntemini çağırarak BitConverter.GetBytes ve parametre olarak işaretsiz bir tamsayı geçirerek. İşaretsiz tamsayılar yalnızca büyüklükleriyle temsil edildiğinden, pozitif değerler negatif değerler olarak yanlış yorumlanabilir. Bu yanlış yorumlamayı önlemek için dizinin sonuna sıfır bayt değeri ekleyebilirsiniz. Sonraki bölümdeki örnekte bir çizim verilmiştir.

• Önceki yöntemlerden herhangi birini çağırmadan dinamik veya statik olarak bayt dizisi oluşturarak veya var olan bir bayt dizisini değiştirerek. Pozitif değerlerin negatif değerler olarak yanlış yorumlanmasını önlemek için dizinin sonuna sıfır baytlık bir değer ekleyebilirsiniz.

Boş value bir diziyseByte, yeni BigInteger nesne değerine BigInteger.Zerobaşlatılır. ise valuenulloluşturucu bir ArgumentNullExceptionoluşturur.

Ayrıca bkz.

• ToByteArray()

BigInteger(Decimal)

Kaynak:

BigInteger.cs

Bir değer kullanarak yapının yeni bir BigInteger örneğini Decimal başlatır.

public:
 BigInteger(System::Decimal value);

public BigInteger(decimal value);

new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger

Public Sub New (value As Decimal)

Parametreler

value

Decimal

Ondalık sayı.

Örnekler

Aşağıdaki örnekte, bir BigInteger(Decimal) nesnenin örneğini oluşturmak için oluşturucunun BigInteger kullanımı gösterilmektedir. Bir değer dizisi Decimal tanımlar ve sonra her değeri oluşturucuya BigInteger(Decimal) geçirir. Nesneye atandığında Decimal değerin BigInteger yuvarlanmak yerine kesildiğini unutmayın.

decimal[] decimalValues = { -1790.533m, -15.1514m, 18903.79m, 9180098.003m };
foreach (decimal decimalValue in decimalValues)
{
   BigInteger number = new BigInteger(decimalValue);
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue);
}
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

let decimalValues = [ -1790.533m; -15.1514m; 18903.79m; 9180098.003m ]

for decimalValue in decimalValues do
    let number = bigint decimalValue
    printfn $"Instantiated BigInteger value {number} from the Decimal value {decimalValue}."
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Dim decimalValues() As Decimal = { -1790.533d, -15.1514d, 18903.79d, 9180098.003d }
For Each decimalValue As Decimal In decimalValues
   Dim number As New BigInteger(decimalValue)
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue)
Next                 
' The example displays the following output:
'    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
'    Instantiated BigInteger value -15 from the Decimal value -15.1514.
'    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
'    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Açıklamalar

Bu oluşturucuyu çağırmanın sonucu, bir değişkene açıkça değer Decimal atamakla BigInteger aynıdır.

Bu oluşturucuyu çağırmak veri kaybına neden olabilir; bir nesne örneği oluşturulurken herhangi bir value kesirli bölümü BigInteger kesilir.

BigInteger(Double)

Kaynak:

BigInteger.cs

Çift duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.

public:
 BigInteger(double value);

public BigInteger(double value);

new System.Numerics.BigInteger : double -> System.Numerics.BigInteger

Public Sub New (value As Double)

Parametreler

value

Double

Çift duyarlıklı kayan nokta değeri.

Özel durumlar

OverflowException

value, NaNveya NegativeInfinityşeklindedirPositiveInfinity.

Örnekler

Aşağıdaki örnekte, bir BigInteger(Double) nesnenin örneğini oluşturmak için oluşturucunun BigInteger kullanımı gösterilmektedir. Ayrıca, veri türünü kullandığınızda Double oluşabilecek duyarlık kaybını da gösterir. A'ya Double büyük bir değer atanır ve bu değer daha sonra bir BigInteger nesneye atanır. Çıktıda gösterildiği gibi, bu atama duyarlık kaybı içerir. Ardından her iki değer de bir artırılır. Çıkış, nesnenin BigInteger değiştirilen değeri yansıttığını gösterirken nesne yansıtmaz Double .

// Create a BigInteger from a large double value.
double doubleValue = -6e20;
BigInteger bigIntValue = new BigInteger(doubleValue);
Console.WriteLine("Original Double value: {0:N0}", doubleValue);
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue);
// Increment and then display both values.
doubleValue++;
bigIntValue += BigInteger.One;
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue);
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue);
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

// Create a BigInteger from a large double value.
let doubleValue = -6e20
let bigIntValue = bigint doubleValue
printfn $"Original Double value: {doubleValue:N0}"
printfn $"Original BigInteger value: {bigIntValue:N0}"
// Increment and then display both values.
let doubleValue = doubleValue + 1.
let bigIntValue = bigIntValue + BigInteger.One
printfn $"Incremented Double value: {doubleValue:N0}"
printfn $"Incremented BigInteger value: {bigIntValue:N0}"
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999

' Create a BigInteger from a large double value.
Dim doubleValue As Double = -6e20
Dim bigIntValue As New BigInteger(doubleValue)
Console.WriteLine("Original Double value: {0:N0}", doubleValue)
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue)
' Increment and then display both values.
doubleValue += 1
bigIntValue += BigInteger.One
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue)
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue)
' The example displays the following output:
'    Original Double value: -600,000,000,000,000,000,000
'    Original BigInteger value: -600,000,000,000,000,000,000
'    Incremented Double value: -600,000,000,000,000,000,000
'    Incremented BigInteger value: -599,999,999,999,999,999,999

Açıklamalar

Bir nesne örneği oluşturulurken parametrenin value herhangi bir BigInteger kesirli bölümü kesilir.

Veri türünün duyarlık olmaması nedeniyle bu oluşturucunun Double çağrılması veri kaybına neden olabilir.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, bir değerine açıkça bir Double değer atamanın sonucu olan değerle BigIntegeraynıdır.

BigInteger(Int32)

Kaynak:

BigInteger.cs

32 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.

public:
 BigInteger(int value);

public BigInteger(int value);

new System.Numerics.BigInteger : int -> System.Numerics.BigInteger

Public Sub New (value As Integer)

Parametreler

value

Int32

32 bit imzalı tamsayı.

Örnekler

Aşağıdaki örnek, 32 bit tamsayı dizisinden değerlerin örneğini BigInteger(Int32) oluşturmak için oluşturucuyu çağırırBigInteger. Ayrıca her 32 bit tamsayı değerini bir BigInteger değişkene atamak için örtük dönüştürme kullanır. Daha sonra elde edilen değerlerin aynı olduğunu BigInteger kurmak için iki değeri karşılaştırır.

int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                   Int32.MaxValue };
BigInteger constructed, assigned;

foreach (int number in integers)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

let integers = [ Int32.MinValue; -10534; -189; 0; 17; 113439; Int32.MaxValue ]

for number in integers do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True

Dim integers() As Integer = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                              Int32.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Integer In integers
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -2147483648 = -2147483648: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       2147483647 = 2147483647: True

Açıklamalar

Bu oluşturucu kullanılarak bir BigInteger nesne örneği oluşturulurken duyarlık kaybı olmaz.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, değerine bir Int32 değer atamanın sonucu olan değerle aynıdırBigInteger.

YapıBigInteger, ByteInt16veya SBytetüründe UInt16bir parametreye sahip oluşturucular içermez. Ancak, Int32 türü 8 bit ve 16 bit işaretli ve işaretsiz tamsayıların imzalı 32 bit tamsayılara örtük olarak dönüştürülmesi destekler. Sonuç olarak, bu dört integral türünden biriyse value bu oluşturucu çağrılır.

BigInteger(Int64)

Kaynak:

BigInteger.cs

64 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.

public:
 BigInteger(long value);

public BigInteger(long value);

new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger

Public Sub New (value As Long)

Parametreler

value

Int64

64 bit işaretli bir tamsayı.

Örnekler

Aşağıdaki örnek, 64 bit tamsayılar dizisinden değerlerin örneğini BigInteger(Int64) oluşturmak için oluşturucuyu çağırırBigInteger. Ayrıca her 64 bit tamsayı değerini bir BigInteger değişkene atamak için örtük dönüştürme kullanır. Daha sonra elde edilen değerlerin aynı olduğunu BigInteger kurmak için iki değeri karşılaştırır.

long[] longs = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                 Int64.MaxValue };
BigInteger constructed, assigned;

foreach (long number in longs)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
                     constructed.Equals(assigned));
}
// The example displays the following output:
//       -9223372036854775808 = -9223372036854775808: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       9223372036854775807 = 9223372036854775807: True

let longs = [ Int64.MinValue; -10534; -189; 0; 17; 113439; Int64.MaxValue ]

for number in longs do
    let constructed = bigint number
    let assigned = number
    printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
//       -9223372036854775808 = -9223372036854775808: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       9223372036854775807 = 9223372036854775807: True

Dim longs() As Long = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                              Int64.MaxValue }
Dim constructed, assigned As BigInteger

For Each number As Long In longs
   constructed = New BigInteger(number)
   assigned = number
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)) 
Next
' The example displays the following output:
'       -9223372036854775808 = -9223372036854775808: True
'       -10534 = -10534: True
'       -189 = -189: True
'       0 = 0: True
'       17 = 17: True
'       113439 = 113439: True
'       9223372036854775807 = 9223372036854775807: True

Açıklamalar

Bu oluşturucu kullanılarak bir BigInteger nesne örneği oluşturulurken duyarlık kaybı olmaz.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, değerine bir Int64 değer atamanın sonucu olan değerle aynıdırBigInteger.

BigInteger(Single)

Kaynak:

BigInteger.cs

Tek duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.

public:
 BigInteger(float value);

public BigInteger(float value);

new System.Numerics.BigInteger : single -> System.Numerics.BigInteger

Public Sub New (value As Single)

Parametreler

value

Single

Tek duyarlıklı kayan nokta değeri.

Özel durumlar

OverflowException

value, NaNveya NegativeInfinityşeklindedirPositiveInfinity.

Örnekler

Aşağıdaki örnekte, bir BigInteger(Single) nesnenin örneğini oluşturmak için oluşturucunun BigInteger kullanımı gösterilmektedir. Ayrıca, veri türünü kullandığınızda Single oluşabilecek duyarlık kaybını da gösterir. A'ya Single büyük bir negatif değer atanır ve bu değer daha sonra bir BigInteger nesneye atanır. Çıktıda gösterildiği gibi, bu atama duyarlık kaybı içerir. Ardından her iki değer de bir artırılır. Çıkış, nesnenin BigInteger değiştirilen değeri yansıttığını gösterirken nesne yansıtmaz Single .

// Create a BigInteger from a large negative Single value
float negativeSingle = Single.MinValue;
BigInteger negativeNumber = new BigInteger(negativeSingle);

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));

negativeSingle++;
negativeNumber++;

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

// Create a BigInteger from a large negative Single value
let negativeSingle = Single.MinValue
let negativeNumber = bigint negativeSingle

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""

let negativeSingle = negativeSingle + 1f
let negativeNumber = negativeNumber + 1I

printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439

' Create a BigInteger from a large negative Single value
Dim negativeSingle As Single = Single.MinValue
Dim negativeNumber As New BigInteger(negativeSingle)

Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))

negativeSingle += 1
negativeNumber += 1
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
' The example displays the following output:
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,440
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,439

Açıklamalar

Bir nesne örneği oluşturulurken parametrenin value herhangi bir BigInteger kesirli bölümü kesilir.

Veri türünün duyarlık olmaması nedeniyle bu oluşturucunun Single çağrılması veri kaybına neden olabilir.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, bir değerine açıkça bir Single değer atamanın sonucu olan değerle BigIntegeraynıdır.

BigInteger(UInt32)

Kaynak:

BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif

System.Numerics.BigInteger.BigInteger(Int64)

İmzasız bir 32 bit tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.

public:
 BigInteger(System::UInt32 value);

[System.CLSCompliant(false)]
public BigInteger(uint value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger

Public Sub New (value As UInteger)

Parametreler

value

UInt32

İşaretsiz bir 32 bit tamsayı değeri.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki örnek, imzasız 32 bit tamsayı dizisinden değerleri başlatmak BigInteger(UInt32) için oluşturucuyu ve atama deyimini kullanırBigInteger. Ardından iki değeri karşılaştırarak bir BigInteger değeri başlatmanın iki yönteminin aynı sonuçları ürettiğini gösterir.

uint[] unsignedValues = { 0, 16704, 199365, UInt32.MaxValue };
foreach (uint unsignedValue in unsignedValues)
{
   BigInteger constructedNumber = new BigInteger(unsignedValue);
   BigInteger assignedNumber = unsignedValue;
   if (constructedNumber.Equals(assignedNumber))
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber);
   else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber);
}
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

let unsignedValues = [ 0u; 16704u; 199365u; UInt32.MaxValue ]

for unsignedValue in unsignedValues do
    let constructedNumber = bigint unsignedValue
    let assignedNumber = unsignedValue

    if constructedNumber.Equals assignedNumber then
        printfn $"Both methods create a BigInteger whose value is {constructedNumber:N0}."
    else
        printfn $"{constructedNumber:N0} ≠ {assignedNumber:N0}"
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.

Dim unsignedValues() As UInteger = { 0, 16704, 199365, UInt32.MaxValue }
For Each unsignedValue As UInteger In unsignedValues
   Dim constructedNumber As New BigInteger(unsignedValue)
   Dim assignedNumber As BigInteger = unsignedValue
   If constructedNumber.Equals(assignedNumber) Then
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber)
   Else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber)
   End If                         
Next
' The example displays the following output:
'    Both methods create a BigInteger whose value is 0.
'    Both methods create a BigInteger whose value is 16,704.
'    Both methods create a BigInteger whose value is 199,365.
'    Both methods create a BigInteger whose value is 4,294,967,295.

Açıklamalar

Bu oluşturucu kullanılarak örneği BigInteger oluşturulurken duyarlık kaybı olmaz.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, değerine bir UInt32 değer atamanın sonucu olan değerle aynıdırBigInteger.

BigInteger(UInt64)

Kaynak:

BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif

System.Numerics.BigInteger.BigInteger(Double)

İmzasız bir 64 bit tamsayı değeriyle yapının yeni bir örneğini BigInteger başlatır.

public:
 BigInteger(System::UInt64 value);

[System.CLSCompliant(false)]
public BigInteger(ulong value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger

Public Sub New (value As ULong)

Parametreler

value

UInt64

İşaretsiz bir 64 bit tamsayı.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki örnek, değerine eşit olan bir BigInteger(UInt64) nesnenin örneğini oluşturmak için oluşturucuyu BigIntegerkullanırMaxValue.

ulong unsignedValue = UInt64.MaxValue;
BigInteger number = new BigInteger(unsignedValue);
Console.WriteLine(number.ToString("N0"));
// The example displays the following output:
//       18,446,744,073,709,551,615

let unsignedValue = UInt64.MaxValue
let number = bigint unsignedValue
printfn $"{number:N0}"
// The example displays the following output:
//       18,446,744,073,709,551,615

Dim unsignedValue As ULong = UInt64.MaxValue
Dim number As New BigInteger(unsignedValue)
Console.WriteLine(number.ToString("N0"))       
' The example displays the following output:
'       18,446,744,073,709,551,615

Açıklamalar

Bu oluşturucu kullanılarak örneği BigInteger oluşturulurken duyarlık kaybı olmaz.

BigInteger Bu oluşturucuyu çağırmanın sonucu olan değer, değerine bir UInt64 değer atamanın sonucu olan değerle aynıdırBigInteger.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Kaynak:

BigInteger.cs

Salt okunur bayt aralığındaki değerleri kullanarak ve isteğe bağlı olarak imzalama kodlamasını ve bitiş bayt sırasını gösteren yeni bir yapı örneği BigInteger başlatır.

public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);

new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigInteger

Public Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)

Parametreler

value

ReadOnlySpan<Byte>

Büyük tamsayıyı temsil eden salt okunur bayt aralığı.

isUnsigned

Boolean

true belirtmek value için işaretsiz kodlama kullanır; aksi takdirde ( false varsayılan değer).

isBigEndian

Boolean

true belirtilmesi value büyük endian bayt düzenindedir; aksi takdirde false (varsayılan değer).