BigInteger Konstruktoren

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

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

Attribute

CLSCompliantAttribute

Ausnahmen

Beispiele

Im folgenden Beispiel wird ein BigInteger Objekt aus einem 5-Element-Bytearray instanziiert, dessen Wert {5, 4, 3, 2, 1} lautet. Anschließend wird der Wert angezeigt, der BigInteger sowohl als dezimale als auch als hexadezimale Zahlen 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). Das erste Element des Bytearrays, dessen Wert 5 ist, definiert den Wert des Bytebytes der niedrigsten Reihenfolge 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 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 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 Teil des letzten Elements im Bytearray. Dieses Bit wird festgelegt (der Wert des Bytes ist 0xFF), wenn das Array aus einem negativen BigInteger Wert erstellt wird. Das Bit wird nicht festgelegt (der Wert des Bytes 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.
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

Im folgenden Beispiel wird veranschaulicht, wie Sie sicherstellen können, dass ein positiver Wert nicht falsch 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.

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 kleiner endischer Reihenfolge angegeben werden, von byte in der niedrigsten Reihenfolge bis hin zum Byte mit der höchsten Reihenfolge. Der numerische Wert 1.000.000.000.000 wird beispielsweise wie in der folgenden Tabelle dargestellt dargestellt:

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

Der Konstruktor erwartet positive Werte im Bytearray, die Sign-and-Magnitude-Darstellung zu verwenden, und negative Werte, um die Komplementdarstellung von zwei zu verwenden. Anders ausgedrückt: Wenn das Bit der höchsten Reihenfolge des Byte value in der höchsten Reihenfolge 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 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 Reihenfolge des Bytes der höchsten Reihenfolge im Array zurückgibt, das für positive Werte auf Null festgelegt ist, besteht keine Möglichkeit, einen positiven Wert als negativ zu interpretieren. Unveränderte Bytearrays, die von der ToByteArray Methode erstellt wurden, werden immer erfolgreich roundtrips ausgeführt, wenn sie an den BigInteger(Byte[]) Konstruktor übergeben werden.

• Durch Aufrufen der BitConverter.GetBytes Methode und Übergeben einer signierten ganzzahligen Zahl als Parameter. Da signierte ganze Zahlen sowohl die Darstellung von Vorzeichen als auch die Darstellung von zwei Ergänzungen behandeln, besteht keine Möglichkeit, einen positiven Wert als negativ zu interpretieren.

• Durch Aufrufen der BitConverter.GetBytes Methode und Übergeben einer nicht signierten ganzzahligen Zahl als Parameter. Da nicht signierte ganze Zahlen 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 dynamisch oder statisch erstellen, ohne unbedingt 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 in einen Wert von BigInteger.Zero. Wenn value ja null, löst der Konstruktor einen ArgumentNullException.

Weitere Informationen

• ToByteArray()

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 BigInteger(System::Decimal value);

public BigInteger(decimal value);

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

Public Sub New (value As Decimal)

Parameter

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

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; Ein Bruchteil eines value Objekts wird beim Instanziieren eines BigInteger Objekts abgeschnitten.

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 BigInteger(double value);

public BigInteger(double value);

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

Public Sub New (value As Double)

Parameter

Ausnahmen

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des BigInteger(Double) Konstruktors zum Instanziieren eines BigInteger Objekts. Außerdem wird der Verlust der Genauigkeit veranschaulicht, der auftreten kann, wenn Sie den Double Datentyp verwenden. A Double wird einem großen Wert zugewiesen, der dann einem BigInteger Objekt zugewiesen wird. Wie die Ausgabe zeigt, umfasst diese Zuordnung 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 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.
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 beim Instanziieren eines BigInteger Objekts abgeschnitten.

Aufgrund des Mangels an Genauigkeit des Double Datentyps kann das Aufrufen dieses Konstruktors zu Datenverlust führen.

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

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 BigInteger(int value);

public BigInteger(int value);

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

Public Sub New (value As Integer)

Parameter

Beispiele

Im folgenden Beispiel wird der BigInteger(Int32) Konstruktor aufgerufen, um Werte aus einem Array mit 32-Bit-Ganzzahlen zu instanziieren BigInteger . Außerdem wird die implizite Konvertierung verwendet, um jeder 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 mithilfe dieses Konstruktors ist kein Genauigkeitsverlust aufgetreten.

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

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 8-Bit- und 16-Bit-signierten und nicht signierten Ganzzahlen in signierte 32-Bit-Ganzzahlen. Daher wird dieser Konstruktor aufgerufen, wenn value es sich um einen dieser vier integralen Typen handelt.

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 BigInteger(long value);

public BigInteger(long value);

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

Public Sub New (value As Long)

Parameter

Beispiele

Im folgenden Beispiel wird der BigInteger(Int64) Konstruktor aufgerufen, um Werte aus einem Array mit 64-Bit-Ganzzahlen zu instanziieren BigInteger . Außerdem wird die implizite Konvertierung verwendet, um jeder 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:
//       -9223372036854775808 = -9223372036854775808: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       9223372036854775807 = 9223372036854775807: True

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

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

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

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

Hinweise

Beim Instanziieren eines BigInteger Objekts mithilfe dieses Konstruktors ist kein Genauigkeitsverlust aufgetreten.

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

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

public:
 BigInteger(float value);

public BigInteger(float value);

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

Public Sub New (value As Single)

Parameter

Ausnahmen

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des BigInteger(Single) Konstruktors zum Instanziieren eines BigInteger Objekts. Außerdem wird der Verlust der Genauigkeit veranschaulicht, der auftreten kann, wenn Sie den Single Datentyp verwenden. A Single wird einem großen negativen Wert zugewiesen, der dann einem BigInteger Objekt zugewiesen wird. Wie die Ausgabe zeigt, umfasst diese Zuordnung 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 Single Objekt 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 beim Instanziieren eines BigInteger Objekts abgeschnitten.

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

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

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

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

Attribute

CLSCompliantAttribute

Beispiele

Im folgenden Beispiel wird der BigInteger(UInt32) Konstruktor und eine Zuordnungsanweisung verwendet, um Werte aus einem Array mit nicht signierten 32-Bit-Ganzzahlen zu initialisieren BigInteger . Anschließend werden die beiden Werte verglichen, um zu veranschaulichen, 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 eines BigInteger mit diesem Konstruktor verwendeten Konstruktors ist kein Genauigkeitsverlust aufgetreten.

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

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

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

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 eines BigInteger mit diesem Konstruktor verwendeten Konstruktors ist kein Genauigkeitsverlust aufgetreten.

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

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

Quelle:

BigInteger.cs

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