BigInteger Konstruktoren

Referenz

Definition

Namespace:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initialisiert eine neue Instanz der BigInteger-Struktur.

Überlädt

BigInteger(Byte[])	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einem Bytearray.
BigInteger(Decimal)	Initialisiert eine neue Instanz der BigInteger-Struktur mit einem Decimal-Wert.
BigInteger(Double)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit doppelter Genauigkeit.
BigInteger(Int32)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl mit Vorzeichen.
BigInteger(Int64)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 64-Bit-Ganzzahl mit Vorzeichen.
BigInteger(Single)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit einfacher Genauigkeit.
BigInteger(UInt32)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl ohne Vorzeichen.
BigInteger(UInt64)	Initialisiert eine neue Instanz der BigInteger-Struktur mit dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einer schreibgeschützten Spanne von Bytes und zeigt optional die Signaturcodierung und die Endianness-Bytereihenfolge an.

BigInteger(Byte[])

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einem Bytearray.

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

Parameter

value: Byte[]

Ein Array der Bytewerte in Little-Endian-Reihenfolge.

Attribute: CLSCompliantAttribute

Ausnahmen

ArgumentNullException

value ist null.

Beispiele

Im folgenden Beispiel wird ein BigInteger Objekt aus einem 5-Element-Bytearray instanziiert, dessen Wert {5, 4, 3, 2, 1} ist. Anschließend wird der Wert angezeigt, der BigInteger sowohl als Dezimal- als auch als Hexadezimalzahlen dargestellt wird, in der Konsole. Ein Vergleich des Eingabearrays mit der Textausgabe macht deutlich, warum diese Überladung des BigInteger Klassenkonstruktors ein BigInteger Objekt erstellt, dessen Wert 4328719365 (oder 0x102030405) ist. Das erste Element des Bytearrays, dessen Wert 5 ist, definiert den Wert des Byte der niedrigsten Ordnung des BigInteger Objekts, der 0x05 ist. Das zweite Element des Bytearrays, dessen Wert 4 ist, definiert den Wert des zweiten Byte des BigInteger Objekts, das 0x04 usw. ist.

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

Im folgenden Beispiel werden ein positiver und ein negativer BigInteger Wert instanziiert, an die ToByteArray -Methode übergeben und dann die ursprünglichen BigInteger Werte aus dem resultierenden Bytearray wiederhergestellt. Beachten Sie, dass die beiden Werte durch identische Bytearrays dargestellt werden. Der einzige Unterschied zwischen ihnen ist das wichtigste Bit des letzten Elements im Bytearray. Dieses Bit wird festgelegt (der Wert des Byte ist 0xFF), wenn das Array aus einem negativen BigInteger Wert erstellt wird. Das Bit wird nicht festgelegt (der Wert des Byte ist 0), wenn das Array aus einem positiven BigInteger Wert erstellt wird.

// 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

Das folgende Beispiel veranschaulicht, wie Sie sicherstellen, dass ein positiver Wert nicht fälschlicherweise als negativer Wert instanziiert wird, indem Sie ein Byte hinzufügen, dessen Wert null am Ende des Arrays ist.

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.

Hinweise

Die einzelnen Bytes im value Array sollten in Little-Endian-Reihenfolge sein, vom Byte der niedrigsten Ordnung bis zum Byte der höchsten Ordnung. Der numerische Wert 1.000.000.000.000 wird beispielsweise wie in der folgenden Tabelle dargestellt:


Hexadezimale Zeichenfolge	E8D4A51000
Bytearray (niedrigster Index zuerst)	00 10 A5 D4 E8 00

Die meisten Methoden, die numerische Werte in Bytearrays konvertieren, z BigInteger.ToByteArray . B. und BitConverter.GetBytes, geben Bytearrays in little-endian-Reihenfolge zurück.

Der Konstruktor erwartet, dass positive Werte im Bytearray die Darstellung von Zeichen und Größe verwenden, und negative Werte verwenden die Komplementdarstellung von zwei. Mit anderen Worten, wenn das Bit der höchsten Reihenfolge des Byte in value der höchsten Ordnung festgelegt ist, ist der resultierende BigInteger Wert negativ. Je nach Quelle des Bytearrays kann dies dazu führen, dass ein positiver Wert als negativer Wert falsch interpretiert wird. Bytearrays werden in der Regel wie folgt generiert:

Durch Aufrufen der BigInteger.ToByteArray -Methode. Da diese Methode ein Bytearray zurückgibt, bei dem das Bit der höchsten Ordnung des Bytes der höchsten Ordnung im Array für positive Werte auf 0 festgelegt ist, besteht keine Möglichkeit, einen positiven Wert falsch als negativ zu interpretieren. Nicht modifizierte Bytearrays, die von der ToByteArray -Methode erstellt wurden, werden immer erfolgreich Roundtrips durchgeführt, wenn sie an den BigInteger(Byte[]) Konstruktor übergeben werden.
Indem Sie die BitConverter.GetBytes -Methode aufrufen und eine ganzzahlige Vorzeichen als Parameter übergeben. Da ganzzahlige Vorzeichen sowohl die Darstellung von Vorzeichen und Größenordnungen als auch die Komplementdarstellung von zwei verarbeiten, besteht keine Möglichkeit, einen positiven Wert als negativ zu interpretieren.
Indem Sie die BitConverter.GetBytes -Methode aufrufen und eine ganze Zahl ohne Vorzeichen als Parameter übergeben. Da ganze Zahlen ohne Vorzeichen nur durch ihre Größe dargestellt werden, können positive Werte als negative Werte falsch interpretiert werden. Um diese Fehlinterpretation zu verhindern, können Sie am Ende des Arrays einen Null-Byte-Wert hinzufügen. Das Beispiel im nächsten Abschnitt enthält eine Abbildung.
Indem Sie ein Bytearray entweder dynamisch oder statisch erstellen, ohne notwendigerweise eine der vorherigen Methoden aufzurufen, oder indem Sie ein vorhandenes Bytearray ändern. Um zu verhindern, dass positive Werte als negative Werte falsch interpretiert werden, können Sie am Ende des Arrays einen Null-Byte-Wert hinzufügen.

Wenn value es sich um ein leeres Byte Array handelt, wird das neue BigInteger Objekt mit dem Wert BigInteger.Zeroinitialisiert. Wenn value ist null, löst der Konstruktor ein aus ArgumentNullException.

Weitere Informationen

ToByteArray()

Gilt für:

BigInteger(Decimal)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur mit einem Decimal-Wert.

public:
 BigInteger(System::Decimal value);

public BigInteger (decimal value);

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

Public Sub New (value As Decimal)

Parameter

value: Decimal

Eine Dezimalzahl

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des BigInteger(Decimal) Konstruktors zum Instanziieren eines BigInteger Objekts. Es definiert ein Array von Decimal Werten und übergibt dann jeden Wert an den BigInteger(Decimal) Konstruktor. Beachten Sie, dass der Decimal Wert abgeschnitten und nicht gerundet wird, wenn er dem BigInteger -Objekt zugewiesen wird.

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.

Hinweise

Das Ergebnis des Aufrufs dieses Konstruktors ist identisch mit dem expliziten Zuweisen eines Decimal Werts zu einer BigInteger Variablen.

Das Aufrufen dieses Konstruktors kann zu Datenverlust führen. jeder Teil von value wird abgeschnitten, wenn ein BigInteger Objekt instanziiert wird.

Gilt für:

BigInteger(Double)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit doppelter Genauigkeit.

public:
 BigInteger(double value);

public BigInteger (double value);

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

Public Sub New (value As Double)

Parameter

value: Double

Ein Gleitkommawert mit doppelter Genauigkeit.

Ausnahmen

OverflowException

value ist NaN, NegativeInfinity oder PositiveInfinity.

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des BigInteger(Double) Konstruktors zum Instanziieren eines BigInteger Objekts. Es veranschaulicht auch den Genauigkeitsverlust, der auftreten kann, wenn Sie den Double Datentyp verwenden. A Double wird ein großer Wert zugewiesen, der dann einem BigInteger -Objekt zugewiesen wird. Wie die Ausgabe zeigt, bedeutet diese Zuweisung einen Genauigkeitsverlust. Beide Werte werden dann um eins erhöht. Die Ausgabe zeigt, dass das BigInteger Objekt den geänderten Wert widerspiegelt, während das Double -Objekt dies nicht tut.

// 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

Hinweise

Jeder Bruchteil des value Parameters wird abgeschnitten, wenn ein BigInteger Objekt instanziiert wird.

Aufgrund der fehlenden Genauigkeit des Datentyps kann der Double Aufruf dieses Konstruktors zu Datenverlust führen.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem expliziten Zuweisen eines Double Werts zu einem BigIntegerergibt.

Gilt für:

BigInteger(Int32)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl mit Vorzeichen.

public:
 BigInteger(int value);

public BigInteger (int value);

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

Public Sub New (value As Integer)

Parameter

value: Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen.

Beispiele

Im folgenden Beispiel wird der BigInteger(Int32) Konstruktor aufgerufen, um Werte aus einem Array von 32-Bit-Ganzzahlen zu instanziieren BigInteger . Außerdem wird eine implizite Konvertierung verwendet, um jeden 32-Bit-Ganzzahlwert einer BigInteger Variablen zuzuweisen. Anschließend werden die beiden Werte verglichen, um festzustellen, dass die resultierenden BigInteger Werte identisch sind.

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

Hinweise

Beim Instanziieren eines BigInteger Objekts mit diesem Konstruktor gibt es keinen Genauigkeitsverlust.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem Zuweisen eines Int32 Werts zu einem BigIntegerergibt.

Die BigInteger -Struktur enthält keine Konstruktoren mit einem Parameter vom Typ Byte, Int16, SByteoder UInt16. Der Int32 Typ unterstützt jedoch die implizite Konvertierung von ganzzahligen 8-Bit- und 16-Bit-Ganzzahlen mit Vorzeichen in 32-Bit-Ganzzahlen mit Vorzeichen. Daher wird dieser Konstruktor aufgerufen, wenn value einer dieser vier integralen Typen ist.

Gilt für:

BigInteger(Int64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 64-Bit-Ganzzahl mit Vorzeichen.

public:
 BigInteger(long value);

public BigInteger (long value);

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

Public Sub New (value As Long)

Parameter

value: Int64

Eine 64-Bit-Ganzzahl mit Vorzeichen.

Beispiele

Im folgenden Beispiel wird der BigInteger(Int64) Konstruktor aufgerufen, um Werte aus einem Array von 64-Bit-Ganzzahlen zu instanziieren BigInteger . Außerdem wird eine implizite Konvertierung verwendet, um jeden 64-Bit-Ganzzahlwert einer BigInteger Variablen zuzuweisen. Anschließend werden die beiden Werte verglichen, um festzustellen, dass die resultierenden BigInteger Werte identisch sind.

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

Hinweise

Beim Instanziieren eines BigInteger Objekts mit diesem Konstruktor gibt es keinen Genauigkeitsverlust.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem Zuweisen eines Int64 Werts zu einem BigIntegerergibt.

Gilt für:

BigInteger(Single)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit einfacher Genauigkeit.

public:
 BigInteger(float value);

public BigInteger (float value);

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

Public Sub New (value As Single)

Parameter

value: Single

Ein Gleitkommawert mit einfacher Genauigkeit.

Ausnahmen

OverflowException

value ist NaN, NegativeInfinity oder PositiveInfinity.

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des BigInteger(Single) Konstruktors zum Instanziieren eines BigInteger Objekts. Es veranschaulicht auch den Genauigkeitsverlust, der auftreten kann, wenn Sie den Single Datentyp verwenden. A Single wird ein großer negativer Wert zugewiesen, der dann einem BigInteger Objekt zugewiesen wird. Wie die Ausgabe zeigt, bedeutet diese Zuweisung einen Genauigkeitsverlust. Beide Werte werden dann um eins erhöht. Die Ausgabe zeigt, dass das BigInteger -Objekt den geänderten Wert widerspiegelt, das Single -Objekt hingegen nicht.

// 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

Hinweise

Jeder Bruchteil des value Parameters wird abgeschnitten, wenn ein BigInteger Objekt instanziiert wird.

Aufgrund der fehlenden Genauigkeit des Datentyps kann der Single Aufruf dieses Konstruktors zu Datenverlust führen.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem expliziten Zuweisen eines Single Werts zu einem BigIntegerergibt.

Gilt für:

BigInteger(UInt32)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Numerics.BigInteger.BigInteger(Int64)

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl ohne Vorzeichen.

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)

Parameter

value: UInt32

Ein 32-Bit-Ganzzahlwert ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel werden der BigInteger(UInt32) Konstruktor und eine Assignment-Anweisung verwendet, um Werte aus einem Array von ganzen 32-Bit-Zahlen ohne Vorzeichen zu initialisieren BigInteger . Anschließend werden die beiden Werte verglichen, um zu zeigen, dass die beiden Methoden zum Initialisieren eines BigInteger Werts identische Ergebnisse erzeugen.

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.

Hinweise

Beim Instanziieren von mit BigInteger diesem Konstruktor kommt es zu keinem Genauigkeitsverlust.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem Zuweisen eines UInt32 Werts zu einem BigIntegerergibt.

Gilt für:

BigInteger(UInt64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Numerics.BigInteger.BigInteger(Double)

Initialisiert eine neue Instanz der BigInteger-Struktur mit dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.

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)

Parameter

value: UInt64

Eine 64-Bit-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel wird der BigInteger(UInt64) -Konstruktor verwendet, um ein BigInteger -Objekt zu instanziieren, dessen Wert gleich MaxValueist.

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

Hinweise

Beim Instanziieren von mit BigInteger diesem Konstruktor kommt es zu keinem Genauigkeitsverlust.

Der BigInteger Wert, der sich aus dem Aufrufen dieses Konstruktors ergibt, ist identisch mit dem Wert, der sich aus dem Zuweisen eines UInt64 Werts zu einem BigIntegerergibt.

Gilt für:

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einer schreibgeschützten Spanne von Bytes und zeigt optional die Signaturcodierung und die Endianness-Bytereihenfolge an.

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)

Parameter

value: ReadOnlySpan<Byte>

Eine schreibgeschützte Spanne von Bytes, die den BigInteger-Wert darstellen.

isUnsigned: Boolean

true, um anzugeben, dass value nicht signierte Codierung verwendet. Andernfalls false (der Standardwert).

isBigEndian: Boolean

true , um anzugeben value , dass in der Big-Endian-Bytereihenfolge liegt, false andernfalls (der Standardwert).

Gilt für:

Freigeben über

BigInteger Konstruktoren

Definition

Überlädt

BigInteger(Byte[])

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

BigInteger(Decimal)

Parameter

Beispiele

Hinweise

Gilt für:

BigInteger(Double)

Parameter

Ausnahmen

Beispiele

Hinweise

Gilt für:

BigInteger(Int32)

Parameter

Beispiele

Hinweise

Gilt für:

BigInteger(Int64)

Parameter

Beispiele

Hinweise

Gilt für:

BigInteger(Single)

Parameter

Ausnahmen

Beispiele

Hinweise

Gilt für:

BigInteger(UInt32)

Parameter

Beispiele

Hinweise

Gilt für:

BigInteger(UInt64)

Parameter

Beispiele

Hinweise

Gilt für:

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Parameter

Gilt für:

Zusätzliche Ressourcen