Aracılığıyla paylaş

BigInteger Oluşturucular

  • Başvuru

Tanım

Ad Alanı:
System.Numerics
Bütünleştirilmiş Kod:
System.Runtime.Numerics.dll
Bütünleştirilmiş Kod:
System.Numerics.dll
Bütünleştirilmiş Kod:
netstandard.dll

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

Aşırı Yüklemeler

BigInteger(Byte[])

Bir bayt dizisindeki BigInteger değerleri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(Decimal)

Değeri kullanarak yapının yeni bir Decimal örneğini BigInteger 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
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

Bir 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 değeridir.

Örnekler

Aşağıdaki örnek, değeri {5, 4, 3, 2, 1} olan 5 öğeli bir 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 değeri 4328719365 (veya 0x102030405) olan bir BigInteger nesneyi neden 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ının 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 sonuçta elde edilen bayt dizisinden özgün BigInteger değerleri geri yükler. İki değerin aynı bayt dizileriyle temsil edildiklerine dikkat edin. 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 değerin hatalı bir şekilde negatif değer olarak örneklenmemesinin nasıl sağlanmadığını 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ırada 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:
Onaltılık dize E8D4A51000
Bayt dizisi (önce en düşük dizin) 00 10 A5 D4 E8 00

Sayısal değerleri ve BitConverter.GetBytesgibi BigInteger.ToByteArray 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 kullanmasını ve negatif değerlerin ikinin tamamlayıcı gösterimini kullanmasını bekler. Başka bir deyişle, içindeki en yüksek sıralı bayt value değerinin en yüksek sıralı biti ayarlanırsa, sonuçta elde BigInteger edilen değer negatif olur. Bayt dizisinin kaynağına bağlı olarak, bu pozitif bir değerin negatif değer olarak yanlış anlaşılmasına neden olabilir. Bayt dizileri genellikle aşağıdaki yollarla oluşturulur:

  • yöntemini çağırarak BigInteger.ToByteArray . 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üş gerçekleştirir.

  • 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ğırıp BitConverter.GetBytes 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ış anlaşılmasını önlemek için, dizinin sonuna sıfır bayt değeri ekleyebilirsiniz.

Boş Byte bir diziysevalue, yeni BigInteger nesne değerine BigInteger.Zerobaşlatılır. ise valuenull, oluşturucu bir ArgumentNullExceptionoluşturur.

Ayrıca bkz.

Şunlara uygulanır

BigInteger(Decimal)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Değeri kullanarak yapının yeni bir Decimal örneğini BigInteger 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 nesnenin örneğini oluşturmak için oluşturucunun BigInteger(Decimal) kullanımı gösterilmektedir. Bir değer dizisi Decimal tanımlar ve sonra her değeri oluşturucuya BigInteger(Decimal) geçirir. Değer nesneye Decimal atandığında 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 Decimal değeri bir değişkene açıkça atamakla BigInteger aynıdır.

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

Şunlara uygulanır

BigInteger(Double)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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, NegativeInfinityveya PositiveInfinityşeklindedirNaN.

Örnekler

Aşağıdaki örnekte, bir BigInteger nesnenin örneğini oluşturmak için oluşturucunun BigInteger(Double) 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 daha sonra bir nesneye atanan büyük bir BigInteger değer atanır. Çıktıda gösterildiği gibi, bu atama duyarlık kaybı içerir. Ardından her iki değer de birer 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ığı olmadığından, bu oluşturucuyu Double çağırmak veri kaybına neden olabilir.

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

Şunlara uygulanır

BigInteger(Int32)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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 oluşturmak BigInteger için oluşturucuyu çağırırBigInteger(Int32). Ayrıca her 32 bit tamsayı değerini bir BigInteger değişkene atamak için örtük dönüştürme kullanır. Ardından, elde BigInteger edilen değerlerin aynı olduğunu 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 BigIntegeraynıdır.

YapıBigInteger, , , Int16SByteveya UInt16türünde Bytebir parametreye sahip oluşturucular içermez. Ancak, Int32 tür 8 bit ve 16 bit işaretli ve imzasız tamsayıların imzalı 32 bit tamsayılara örtük dönüştürmesini destekler. Sonuç olarak, bu dört tam sayı türünden biriyse value , bu oluşturucu çağrılır.

Şunlara uygulanır

BigInteger(Int64)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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 tamsayı.

Örnekler

Aşağıdaki örnek, 64 bit tamsayı dizisinden değerlerin örneğini BigInteger oluşturmak için oluşturucuyu çağırırBigInteger(Int64). Ayrıca her 64 bit tamsayı değerini bir BigInteger değişkene atamak için örtük dönüştürme kullanır. Ardından, elde BigInteger edilen değerlerin aynı olduğunu 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:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: 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:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: 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:
'       -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 Int64 değer atamanın sonucu olan değerle BigIntegeraynıdır.

Şunlara uygulanır

BigInteger(Single)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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, NegativeInfinityveya PositiveInfinityşeklindedirNaN.

Örnekler

Aşağıdaki örnekte, bir BigInteger nesnenin örneğini oluşturmak için oluşturucunun BigInteger(Single) 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. Her iki değer de bir artırılır. Çıkış, nesnenin BigInteger değiştirilen değeri yansıttığını gösterirken Single nesne yansıtmaz.

// 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ığı olmadığından, 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.

Şunlara uygulanır

BigInteger(UInt32)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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, imzalanmamış 32 bitlik tamsayı dizisinden değerleri başlatmak BigInteger için oluşturucuyu ve atama deyimini kullanırBigInteger(UInt32). 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 bir BigInteger örneği oluşturulurken duyarlık kaybı olmaz.

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

Şunlara uygulanır

BigInteger(UInt64)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
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 nesnenin örneğini oluşturmak için oluşturucuyu MaxValuekullanırBigInteger(UInt64).

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 bir BigInteger örneği oluşturulurken duyarlık kaybı olmaz.

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

Şunlara uygulanır

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Salt okunur bayt aralığındaki değerleri kullanarak ve isteğe bağlı olarak imzalama kodlamasını ve endianness bayt sırasını belirterek yapının yeni bir örneğini 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 imzasız kodlama kullanır; aksi takdirde false (varsayılan değer).

isBigEndian
Boolean

true value belirtilmesi büyük endian bayt sırasına göredir; aksi takdirde false (varsayılan değer).

Şunlara uygulanır