(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

BigInteger-Struktur

Stellt eine beliebig große ganze Zahl mit Vorzeichen dar.

Namespace:  System.Numerics
Assembly:  System.Numerics (in System.Numerics.dll)

[SerializableAttribute]
public struct BigInteger : IFormattable, 
	IComparable, IComparable<BigInteger>, IEquatable<BigInteger>

Der BigInteger-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Byte[])Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung der Werte in einem Bytearray.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Decimal)Initialisiert eine neue Instanz der BigInteger-Struktur mit einem Decimal-Wert.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Double)Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit doppelter Genauigkeit.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Int32)Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl mit Vorzeichen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Int64)Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 64-Bit-Ganzzahl mit Vorzeichen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(Single)Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung eines Gleitkommawerts mit einfacher Genauigkeit.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(UInt32)Initialisiert eine neue Instanz der BigInteger-Struktur unter Verwendung des Werts einer 32-Bit-Ganzzahl ohne Vorzeichen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBigInteger(UInt64)Initialisiert eine neue Instanz der BigInteger-Struktur mit dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsEvenGibt an, ob der Wert des aktuellen BigInteger-Objekts eine gerade Zahl ist.
Öffentliche EigenschaftUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsOneGibt an, ob der Wert des aktuellen BigInteger-Objekts BigInteger.One ist.
Öffentliche EigenschaftUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsPowerOfTwoGibt an, ob der Wert des aktuellen BigInteger-Objekts eine Potenz von Zwei ist.
Öffentliche EigenschaftUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsZeroGibt an, ob der Wert des aktuellen BigInteger-Objekts BigInteger.Zero ist.
Öffentliche EigenschaftStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMinusOneRuft einen Wert ab, der die Zahl -1 darstellt.
Öffentliche EigenschaftStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsOneRuft einen Wert ab, der die Zahl 1 darstellt.
Öffentliche EigenschaftUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSignRuft eine Zahl ab, die das Vorzeichen (negativ, positiv, oder 0 (null)) des aktuellen BigInteger-Objekts angibt.
Öffentliche EigenschaftStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsZeroRuft einen Wert ab, der die Zahl null (0) darstellt.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAbsRuft den absoluten Wert eines BigInteger-Objekts ab.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAddAddiert zwei BigInteger-Werte und gibt das Ergebnis zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareVergleicht zwei BigInteger-Werte und gibt eine ganze Zahl zurück, die angibt, ob der erste Wert kleiner oder größer als der zweite Wert oder gleich dem zweiten Wert ist.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(BigInteger)Vergleicht diese Instanz mit einem zweiten BigInteger und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(Int64)Vergleicht diese Instanz mit einer 64-Bit-Ganzzahl mit Vorzeichen und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der 64-Bit-Ganzzahl mit Vorzeichen ist oder mit diesem übereinstimmt.
Öffentliche MethodeCompareTo(Object)Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(UInt64)Vergleicht diese Instanz mit einer 64-Bit-Ganzzahl ohne Vorzeichen und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der 64-Bit-Ganzzahl ohne Vorzeichen ist oder mit diesem übereinstimmt.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDivideDividiert einen BigInteger-Wert durch einen anderen und gibt das Ergebnis zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDivRemDividiert einen BigInteger-Wert durch einen anderen, gibt das Ergebnis zurück und gibt den Rest in einem Ausgabeparameter zurück.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(BigInteger)Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger-Objekt über den gleichen Wert verfügen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Int64)Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl mit Vorzeichen über den gleichen Wert verfügen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen. (Überschreibt ValueType.Equals(Object).)
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(UInt64)Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl ohne Vorzeichen über den gleichen Wert verfügen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeGibt den Hashcode für das aktuelle BigInteger-Objekt zurück. (Überschreibt ValueType.GetHashCode().)
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreatestCommonDivisorSucht den größten gemeinsamen Divisor von zwei BigInteger-Werten.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLog(BigInteger)Gibt den natürlichen Logarithmus (zur Basis e) der angegebenen Zahl zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLog(BigInteger, Double)Gibt den Logarithmus einer angegebenen Zahl bezüglich einer angegebenen Basis zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLog10Gibt den Logarithmus einer angegebenen Zahl zur Basis 10 zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMaxGibt den größeren der beiden BigInteger-Werte zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMinGibt den kleineren der beiden BigInteger-Werte zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsModPowFührt eine Modulodivision für eine zur Potenz einer anderen Zahl erhobenen Zahl aus.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMultiplyGibt das Produkt der beiden BigInteger-Werte zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNegateNegiert einen angegebenen BigInteger-Wert.
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsParse(String)Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsParse(String, NumberStyles)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsParse(String, IFormatProvider)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsParse(String, NumberStyles, IFormatProvider)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturabhängigen Format in das entsprechende BigInteger.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPowPotenziert einen BigInteger-Wert mit einem angegebenen Wert.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemainderFührt die Ganzzahldivision von zwei BigInteger-Werten aus und gibt den Rest zurück.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSubtractSubtrahiert einen BigInteger-Wert von einem anderen und gibt das Ergebnis zurück.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToByteArrayKonvertiert einen BigInteger-Wert in ein Bytearray.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString()Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts in die entsprechende Zeichenfolgendarstellung. (Überschreibt ValueType.ToString().)
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(IFormatProvider)Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(String)Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(String, IFormatProvider)Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats und der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsTryParse(String, BigInteger)Versucht, die Zeichenfolgendarstellung einer Zahl in deren BigInteger-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsTryParse(String, NumberStyles, IFormatProvider, BigInteger)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in das entsprechende BigInteger und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.
Zum Seitenanfang

  NameBeschreibung
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAdditionAddiert die Werte von zwei angegebenen BigInteger-Objekten.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBitwiseAndFührt eine bitweise And-Operation für zwei BigInteger-Werte aus.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsBitwiseOrFührt eine bitweise Or-Operation für zwei BigInteger-Werte aus.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDecrementDekrementiert einen BigInteger-Wert um 1.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDivisionDividiert einen angegebenen BigInteger-Wert durch einen anderen angegebenen BigInteger-Wert mit einer Ganzzahldivision.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquality(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und der Wert einer langen ganzen Zahl mit Vorzeichen gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquality(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob die Werte von zwei BigInteger-Objekten gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquality(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und der Wert einer langen ganzen Zahl ohne Vorzeichen gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquality(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob der Wert einer langen ganzen Zahl mit Vorzeichen und ein BigInteger-Wert gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquality(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob der Wert einer langen ganzen Zahl ohne Vorzeichen und ein BigInteger-Wert gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExclusiveOrFührt eine bitweise exklusive Or-Operation (XOr-Operation) für zwei BigInteger-Werte aus.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Int32)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl mit Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Decimal)Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Decimal-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Int16)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl mit Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to SByte)Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen 8-Bit-Wert mit Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to UInt16)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 16-Bit-Ganzzahl ohne Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to UInt32)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 32-Bit-Ganzzahl ohne Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Int64)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl mit Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Single)Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Gleitkommawert mit einfacher Genauigkeit.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Double)Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Double-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to UInt64)Definiert eine explizite Konvertierung eines BigInteger-Objekts in den Wert einer 64-Bit-Ganzzahl ohne Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(BigInteger to Byte)Definiert eine explizite Konvertierung eines BigInteger-Objekts in einen Bytewert ohne Vorzeichen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(Decimal to BigInteger)Definiert eine explizite Konvertierung eines Decimal-Objekts in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(Double to BigInteger)Definiert eine explizite Konvertierung eines Double-Werts in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsExplicit(Single to BigInteger)Definiert eine explizite Konvertierung eines Single-Objekts in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThan(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger größer als der Wert einer 64-Bit-Ganzzahl mit Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThan(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als ein anderer BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThan(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThan(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThan(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqual(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als der oder gleich dem Wert einer 64-Bit-Ganzzahl mit Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqual(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer oder gleich einem anderen BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqual(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert größer als der oder gleich dem Wert einer 64-Bit-Ganzzahl ohne Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqual(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein oder gleich einem BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqual(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen größer als ein oder gleich einem BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(Byte to BigInteger)Definiert eine implizite Konvertierung eines Bytewerts ohne Vorzeichen in ein BigInteger-Objekt.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(Int16 to BigInteger)Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(Int32 to BigInteger)Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(Int64 to BigInteger)Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(SByte to BigInteger)Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl mit Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(UInt16 to BigInteger)Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(UInt32 to BigInteger)Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsImplicit(UInt64 to BigInteger)Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIncrementInkrementiert einen BigInteger-Wert um 1.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequality(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl mit Vorzeichen ungleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequality(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob zwei BigInteger-Objekte über unterschiedliche Werte verfügen.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequality(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert und eine 64-Bit-Ganzzahl ohne Vorzeichen ungleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequality(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen und ein BigInteger-Wert ungleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequality(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen und ein BigInteger-Wert ungleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLeftShiftVerschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach links.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThan(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl mit Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThan(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als ein anderer BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThan(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als eine 64-Bit-Ganzzahl ohne Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThan(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThan(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als ein BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqual(BigInteger, Int64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als oder gleich einer 64-Bit-Ganzzahl mit Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqual(BigInteger, BigInteger)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner oder gleich einem anderen BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqual(BigInteger, UInt64)Gibt einen Wert zurück, der angibt, ob ein BigInteger-Wert kleiner als oder gleich einer 64-Bit-Ganzzahl ohne Vorzeichen ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqual(Int64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein oder gleich einem BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqual(UInt64, BigInteger)Gibt einen Wert zurück, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als ein oder gleich einem BigInteger-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsModulusGibt den Rest aus der Division zweier angegebener BigInteger-Werte zurück.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMultiplyMultipliziert zwei angegebene BigInteger-Werte.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsOnesComplementGibt das bitweise Einerkomplement eines BigInteger-Werts zurück.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRightShiftVerschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach rechts.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSubtractionSubtrahiert einen BigInteger-Wert von einem anderen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsUnaryNegationNegiert einen angegebenen BigInteger-Wert.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsUnaryPlusGibt den Wert des BigInteger-Operanden zurück. (Das Vorzeichen des Operanden wird nicht geändert.)
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIComparable.CompareToVergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
Zum Seitenanfang

Der BigInteger-Typ ist ein unveränderlicher Typ, der eine beliebig große ganze Zahl darstellt, deren Wert theoretisch keine obere oder untere Grenze hat. Die Member des BigInteger-Typs sind eng an die der anderen ganzzahligen Typen angelehnt (die Typen Byte, Int16, Int32, Int64, SByte, UInt16, UInt32 und UInt64). Dieser Typ unterscheidet sich von den anderen ganzzahligen Typen in .NET Framework, deren Bereich von ihrer MinValue-Eigenschaft und MaxValue-Eigenschaft angegeben wird.

HinweisHinweis

Da der BigInteger-Typ unveränderlich ist (siehe Veränderlichkeit und BigInteger-Struktur) und da er keine Ober- oder Untergrenzen hat, kann ein OutOfMemoryException für jede Operation ausgelöst werden, die bewirkt, dass ein BigInteger-Wert zu groß wird.

Instanziieren eines BigInteger-Objekts

Sie können auf mehrere Weisen ein BigInteger-Objekt instanziieren:

  • Sie können das new-Schlüsselwort verwenden und irgendeinen ganzzahligen oder Gleitkomma-Wert als Parameter an den BigInteger-Konstruktor übergeben. (Gleitkommawerte werden abgeschnitten, bevor sie dem BigInteger zugewiesen werden.) Im folgenden Beispiel wird die Verwendung des new-Schlüsselworts zum Instanziieren von BigInteger-Werten veranschaulicht.

    
    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952		
    
    
    
  • Sie können eine BigInteger-Variable deklarieren und ihr einen Wert zuweisen wie bei jedem anderen numerischen Typ, solange dieser Wert ein ganzzahliger Typ ist. Im folgenden Beispiel wird eine Zuweisung verwendet, um einen BigInteger-Wert aus einem Int64 zu erstellen.

    
    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    
    
  • Sie können einem BigInteger-Objekt einen Dezimal- oder Gleitkomma-Wert zuweisen, wenn Sie den Wert zuerst umwandeln oder konvertieren. Im folgenden Beispiel werden ein Double-Wert und ein Decimal-Wert explizit in einen BigInteger umgewandelt (in C#) bzw. konvertiert (in Visual Basic).

    
    BigInteger assignedFromDouble = (BigInteger) 179032.6541;
    Console.WriteLine(assignedFromDouble);   
    BigInteger assignedFromDecimal = (BigInteger) 64312.65m;      
    Console.WriteLine(assignedFromDecimal);
    // The example displays the following output:
    //   179032
    //   64312      
    
    
    

Diese Methoden ermöglichen es Ihnen, ein BigInteger-Objekt zu instanziieren, dessen Wert im Bereich eines der vorhandenen numerischen Typen liegt. Sie können ein BigInteger-Objekt instanziieren, dessen Wert auf eine von drei Weisen den Bereich der vorhandenen numerischen Typen überschreiten kann:

  • Sie können das new-Schlüsselwort verwenden und ein Bytearray von beliebiger Größe für den BigInteger.BigInteger-Konstruktor bereitstellen. Beispiel:

    
    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);    
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    
    
  • Sie können die Parse-Methode oder TryParse-Methode aufrufen, um die Zeichenfolgendarstellung einer Zahl in einen BigInteger zu konvertieren. Beispiel:

    
    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    
    
  • Sie können eine static (Shared in Visual Basic) BigInteger-Methode aufrufen, die einen Vorgang für einen numerischen Ausdruck ausführt und ein berechnetes BigInteger-Ergebnis zurückgibt. Im folgenden Beispiel wird dieses gemacht, indem UInt64.MaxValue mit 3 potenziert und einem BigInteger das Ergebnis zugewiesen wird.

    
    BigInteger number = BigInteger.Pow(UInt64.MaxValue, 3);
    Console.WriteLine(number);
    // The example displays the following output:
    //    6277101735386680762814942322444851025767571854389858533375
    
    
    

Der nicht initialisierte Wert einer BigInteger ist Zero.

Ausführen von Operationen mit BigInteger-Werten

Sie können eine BigInteger-Instanz in derselben Weise verwenden wie andere Ganzzahltypen. BigInteger überlädt die numerischen Standardoperatoren, damit Sie grundlegende mathematische Operationen ausführen können, z. B. Addition, Subtraktion, Division, Multiplikation, Subtraktion, Negation und unäre Negation. Sie können auch zwei BigInteger-Werte mithilfe der standardmäßigen numerischen Operatoren miteinander vergleichen. Wie die anderen ganzzahligen Typen unterstützt BigInteger ebenfalls die bitweisen Operatoren And, Or, XOr, Linksschiebeoperatoren und Rechtsschiebeoperatoren. Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, stellt die BigInteger-Struktur auch entsprechende Methoden zum Ausführen von mathematischen Operationen bereit. Dazu gehören Add, Divide, Multiply, Negate, Subtract und weitere.

Viele Member der BigInteger-Struktur entsprechen direkt Membern der anderen ganzzahligen Typen. Außerdem fügt BigInteger Member wie die folgenden hinzu:

  • Sign , mit dem ein Wert zurückgegeben wird, der das Vorzeichen eines BigInteger-Werts angibt.

  • Abs , mit dem der absolute Wert eines BigInteger-Werts zurückgegeben wird.

  • DivRem , mit der der Quotient und der Rest einer Division zurückgegeben werden.

  • GreatestCommonDivisor , mit der der größte gemeinsame Divisor von zwei BigInteger-Werten zurückgegeben wird.

Viele dieser zusätzlichen Member entsprechen den Membern der Math-Klasse, die die Funktionen für die Verwendung der primitiven numerischen Typen bereitstellt.

Veränderlichkeit und die BigInteger-Struktur

Im folgenden Beispiel wird ein BigInteger-Objekt instanziiert und dann wird sein Wert um 1 inkrementiert.


BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);


Obwohl dieses Beispiel den Wert des vorhandenen Objekts zu ändern scheint, ist dies nicht der Fall. BigInteger -Objekte sind unveränderlich, d. h., dass die Common Language Runtime intern ein neues BigInteger-Objekt erstellt und diesem einen Wert zuweist, der um eins größer ist als der vorherige Wert. Dieses neue Objekt wird daraufhin an den Aufrufer zurückgegeben.

HinweisHinweis

Die anderen numerischen Typen in .NET Framework sind ebenfalls unveränderbar. Da der BigInteger-Typ jedoch keine Ober- oder Untergrenzen hat, können seine Werte äußerst groß werden und messbare Auswirkungen auf die Leistung haben.

Obwohl dieser Prozess für den Aufrufer transparent ist, verursacht er eine Leistungseinbuße. In einigen Fällen, besonders wenn Operationen in einer Schleife für sehr große BigInteger-Werte wiederholt werden, kann diese Leistungseinbuße bedeutend sein. Zum Beispiel wird im folgenden Beispiel bis zu 1 Million mal wiederholend eine Operation ausgeführt, und ein BigInteger-Wert wird jedes Mal um eins inkrementiert, wenn die Operation erfolgreich ist.


BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   number++;
}


In so einem Fall können Sie die Leistung durch Ausführen aller Zwischenzuweisungen mit einer Int32-Variablen verbessern. Dem BigInteger-Objekt kann der endgültige Wert der Variable dann zugewiesen werden, wenn die Schleife beendet wird. Dies wird im folgenden Beispiel veranschaulicht.


BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
int actualRepetitions = 0;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   actualRepetitions++;
}
number += actualRepetitions;


Arbeiten mit Bytearrays und Hexadezimalzeichenfolgen

Wenn Sie BigInteger-Werte in Bytearrays konvertieren oder wenn Sie Bytearrays in BigInteger-Werte konvertieren, müssen Sie die Reihenfolge von Bytes berücksichtigen. Die BigInteger-Struktur erwartet, dass die einzelnen Bytes in einem Bytearray in Little-Endian-Reihenfolge (d. h. die niederwertigen Bytes des Werts gehen den höherwertigen Bytes voraus) angezeigt werden. Sie können einen Roundtrip eines BigInteger-Werts ausführen, indem Sie die ToByteArray-Methode aufrufen und das resultierende Bytearray dann an den BigInteger(Byte[])-Konstruktor übergeben, wie das folgende Beispiel zeigt.


BigInteger number = BigInteger.Pow(Int64.MaxValue, 2);     
Console.WriteLine(number);

// Write the BigInteger value to a byte array.
byte[] bytes = number.ToByteArray();

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0:X2} ", byteValue);
Console.WriteLine();

// Restore the BigInteger value from a Byte array.
BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine(newNumber);
// The example displays the following output:
//    8.5070591730234615847396907784E+37
//    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
//    
//    8.5070591730234615847396907784E+37


Um einen BigInteger-Wert in einem Bytearray zu instanziieren, der einen Wert eines anderen ganzzahligen Typs darstellt, können Sie den ganzzahligen Wert an die BitConverter.GetBytes-Methode übergeben und dann das resultierende Bytearray an den BigInteger(Byte[])-Konstruktor übergeben. Im folgenden Beispiel wird ein BigInteger-Wert aus einem 5-Elemente-Bytearray, das einen Int16-Wert darstellt, instanziiert.


short originalValue = 30000;
Console.WriteLine(originalValue);

// Convert the Int16 value to a byte array.
byte[] bytes = BitConverter.GetBytes(originalValue);

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0} ", byteValue.ToString("X2"));
Console.WriteLine();

// Pass byte array to the BigInteger constructor.
BigInteger number = new BigInteger(bytes);
Console.WriteLine(number);
// The example displays the following output:
//       30000
//       0x30 0x75
//       30000


Die BigInteger-Struktur geht davon aus, dass negative Werte in der Zweierkomplementdarstellung gespeichert werden. Da die BigInteger-Struktur einen numerischen Wert ohne feste Länge darstellt, interpretiert der BigInteger(Byte[])-Konstruktor das höchstwertige Byte des letzten Bytes im Array immer als Vorzeichenbit. Um zu verhindern, dass der BigInteger(Byte[])-Konstruktor die Zweierkomplementdarstellung eines negativen Werts mit der Vorzeichen-Wert-Darstellung eines positiven Werts verwechselt, sollten positive Werte, in denen das höchstwertige Byte des letzten Bytes im Bytearray normalerweise festgelegt würde, ein zusätzliches Byte einschließen, dessen Wert 0 ist. 0xC0 0xBD 0xF0 0xFF ist z. B. die Little-Endian-Hexadezimaldarstellung von entweder -1.000.000 oder 4.293.967.296. Da das höchstwertige Byte des letzten Bytes in diesem Array gesetzt ist, würde der Wert des Bytearrays vom BigInteger(Byte[])-Konstruktor als -1.000.000 interpretiert werden. Um einen BigInteger zu instanziieren, dessen Wert positiv ist, muss ein Bytearray, dessen Elemente 0xC0 0xBD 0xF0 0xFF 0x00 sind, an den Konstruktor übergeben werden. Dies wird anhand des folgenden Beispiels veranschaulicht:


int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

byte[] negativeBytes = BitConverter.GetBytes(negativeNumber); 
BigInteger negativeBigInt = new BigInteger(negativeBytes);
Console.WriteLine(negativeBigInt.ToString("N0"));

byte[] tempPosBytes = BitConverter.GetBytes(positiveNumber);
byte[] positiveBytes = new byte[tempPosBytes.Length + 1];
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length);
BigInteger positiveBigInt = new BigInteger(positiveBytes);
Console.WriteLine(positiveBigInt.ToString("N0")); 
// The example displays the following output:
//    -1,000,000
//    4,293,967,296      


Von der ToByteArray-Methode aus positiven Werten erstellte Bytearrays enthalten dieses zusätzliche Byte mit dem Wert 0 (null). Daher kann die BigInteger-Struktur erfolgreich einen Roundtrip der Werte ausführen, indem diese Bytearrays zugewiesen und dann aus diesen wiederhergestellt werden, wie das folgende Beispiel zeigt.


BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"));
byte[] bytes = positiveValue.ToByteArray();

foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue = new BigInteger(bytes);
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"));

Console.WriteLine();

Console.WriteLine("Negative value: " + negativeValue.ToString("N0"));
bytes = negativeValue.ToByteArray();
foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue = new BigInteger(bytes);
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"));
// The example displays the following output:
//       Positive value: 15,777,216
//       C0 BD F0 00
//       Restored positive value: 15,777,216
//       
//       Negative value: -1,000,000
//       C0 BD F0
//       Restored negative value: -1,000,000


Sie müssen jedoch möglicherweise dieses zusätzliche Byte mit dem Wert 0 zu Bytearrays hinzufügen, die dynamisch vom Entwickler erstellt werden oder von Methoden zurückgegeben werden, die ganze Zahlen ohne Vorzeichen in Bytearrays konvertieren (z. B. BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), und BitConverter.GetBytes(UInt64)).

Wenn Sie eine Hexadezimalzeichenfolge analysieren, gehen die BigInteger.Parse(String, NumberStyles)-Methode und BigInteger.Parse(String, NumberStyles, IFormatProvider)-Methode davon aus, dass, wenn das höchstwertige Byte des ersten Bytes in der Zeichenfolge festgelegt wird oder wenn die erste Hexadezimalziffer der Zeichenfolge die unteren vier Bits eines Bytewerts darstellt, der Wert mit Zweierkomplementdarstellung dargestellt wird. Sowohl "FF01" als auch "F01" stellen z. B. den Dezimalwert -255 dar. Um positive von negativen Werten zu unterscheiden, sollten positive Werte eine führende Null einschließen. Wenn den relevanten Überladungen der ToString-Methode die "X"-Formatzeichenfolge übergeben wird, fügen Sie der zurückgegebenen Hexadezimalzeichenfolge eine führende Null für positive Werte hinzu. Dies macht es möglich, BigInteger-Werte mit der ToString-Methode und Parse-Methode auszuführen, wie das folgende Beispiel zeigt.


BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

string negativeHex = negativeNumber.ToString("X");
string positiveHex = positiveNumber.ToString("X");

BigInteger negativeNumber2, positiveNumber2;  
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber);
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber);

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2);                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2);                                         
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.


Die Hexadezimalzeichenfolgen, die durch Aufrufen der ToString-Methoden der anderen ganzzahligen Typen oder der Überladungen der ToString-Methode erstellt werden, die einen toBase-Parameter einschließt, geben jedoch das Vorzeichen des Werts oder des Quelldaten-Typs nicht an, von dem die Hexadezimalzeichenfolge abgeleitet wurde. Erfolgreich einen BigInteger-Wert aus so einer Zeichenfolge zu instanziieren, erfordert etwas zusätzliche Logik. Das folgende Beispiel zeigt eine mögliche Implementierung.


using System;
using System.Globalization;
using System.Numerics;

public struct HexValue
{
   public int Sign;
   public string Value;
}

public class Example
{
   public static void Main()
   {
      uint positiveNumber = 4039543321;
      int negativeNumber = -255423975;

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);

      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);

      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;

      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt);

      hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt);
   }
}
// The example displays the following output:
//       Converted 4039543321 to F0C68A19 and back to 4039543321.
//       Converted -255423975 to f0c68a19 and back to -255423975.


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Unterstützt in: 4

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft