BigInteger Konstruktoren

  • Referenz

Definition

Namespace:
System.Numerics
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

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 Hexadezimalzahl 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 Bytes der niedrigsten Ordnung des BigInteger Objekts, das 0x05 ist. Das zweite Element des Bytearrays, dessen Wert 4 ist, definiert den Wert des zweiten Byte des BigInteger Objekts, das 0x04 ist usw.

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

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 wird 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 liegt im wichtigsten 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 ist nicht festgelegt (der Wert des Byte ist null), 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.
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

Im folgenden Beispiel wird veranschaulicht, wie Sichergestellt wird, dass ein positiver Wert nicht fälschlicherweise als negativer Wert instanziiert wird, indem ein Byte hinzugefügt wird, 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.

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-endianischer 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 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ößen und negative Werte die Komplementdarstellung von zwei verwenden. Anders ausgedrückt: Wenn das Bit der höchsten Ordnung des Bytes der höchsten Ordnung in value festgelegt ist, ist der resultierende BigInteger Wert negativ. Abhängig von der 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 mit dem Bit der höchsten Ordnung des Bytes der höchsten Ordnung im Array zurückgibt, das für positive Werte auf 0 festgelegt ist, besteht keine Möglichkeit, einen positiven Wert falsch als negativ zu interpretieren. Unveränderte Bytearrays, die von der ToByteArray -Methode erstellt werden, sind immer erfolgreich Roundtrips, wenn sie an den BigInteger(Byte[]) Konstruktor übergeben werden.

  • Indem Sie die BitConverter.GetBytes -Methode aufrufen und eine ganze Zahl mit Vorzeichen als Parameter übergeben. Da ganze Zahlen mit Vorzeichen und Größe sowohl die Darstellung von Vorzeichen als auch die Komplementdarstellung von zwei verarbeiten, besteht keine Chance, 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 ein leeres Byte Array ist, wird das neue BigInteger Objekt mit dem Wert BigInteger.Zeroinitialisiert. Wenn value ist null, löst der Konstruktor eine aus ArgumentNullException.

Weitere Informationen

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

Im folgenden Beispiel wird die Verwendung des BigInteger(Decimal) Konstruktors zum Instanziieren eines BigInteger Objekts veranschaulicht. 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.

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.

Der Aufruf dieses Konstruktors kann zu Datenverlust führen. ein beliebiger Bruchteil 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

Im folgenden Beispiel wird die Verwendung des BigInteger(Double) Konstruktors zum Instanziieren eines BigInteger Objekts veranschaulicht. Außerdem wird der Genauigkeitsverlust veranschaulicht, der auftreten kann, wenn Sie den Double Datentyp verwenden. Einem 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, das Double -Objekt hingegen nicht.

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

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 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 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 ganzen 8-Bit- und 16-Bit-Ganzzahlen mit Vorzeichen in ganze 32-Bit-Zahlen 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 die 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

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

Im folgenden Beispiel wird die Verwendung des BigInteger(Single) Konstruktors zum Instanziieren eines BigInteger Objekts veranschaulicht. Außerdem wird der Genauigkeitsverlust veranschaulicht, der auftreten kann, wenn Sie den Single Datentyp verwenden. Einem 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
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.

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

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: