Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

BigInteger-Struktur

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

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>

NameBeschreibung
System_CAPS_pubmethodBigInteger(Byte[])

Initialisiert eine neue Instanz der der BigInteger -Struktur mit den Werten in einem Bytearray.

System_CAPS_pubmethodBigInteger(Decimal)

Initialisiert eine neue Instanz der der BigInteger -Struktur unter Verwendung einer Decimal Wert.

System_CAPS_pubmethodBigInteger(Double)

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

System_CAPS_pubmethodBigInteger(Int32)

Initialisiert eine neue Instanz der der BigInteger -Struktur unter Verwendung einen 32-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_pubmethodBigInteger(Int64)

Initialisiert eine neue Instanz der der BigInteger -Struktur unter Verwendung einen 64-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_pubmethodBigInteger(Single)

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

System_CAPS_pubmethodBigInteger(UInt32)

Initialisiert eine neue Instanz der der BigInteger -Struktur unter Verwendung einen 32-Bit-Ganzzahl ohne Vorzeichen-Wert.

System_CAPS_pubmethodBigInteger(UInt64)

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

NameBeschreibung
System_CAPS_pubpropertyIsEven

Gibt an, ob der Wert des aktuellen BigInteger Objekt eine gerade Zahl ist.

System_CAPS_pubpropertyIsOne

Gibt an, ob der Wert des aktuellen BigInteger Objekt ist BigInteger.One.

System_CAPS_pubpropertyIsPowerOfTwo

Gibt an, ob der Wert des aktuellen BigInteger -Objekts eine Potenz von zwei ist.

System_CAPS_pubpropertyIsZero

Gibt an, ob der Wert des aktuellen BigInteger Objekt ist BigInteger.Zero.

System_CAPS_pubpropertySystem_CAPS_staticMinusOne

Ruft einen Wert ab, der die Zahl -1 darstellt.

System_CAPS_pubpropertySystem_CAPS_staticOne

Ruft einen Wert ab, der die Zahl 1 darstellt.

System_CAPS_pubpropertySign

Ruft eine Zahl, die das Vorzeichen angibt (negativ, positiv oder 0 (null)) des aktuellen BigInteger Objekt.

System_CAPS_pubpropertySystem_CAPS_staticZero

Ruft einen Wert ab, der die Zahl null (0) darstellt.

NameBeschreibung
System_CAPS_pubmethodSystem_CAPS_staticAbs(BigInteger)

Ruft den absoluten Wert einer BigInteger Objekt.

System_CAPS_pubmethodSystem_CAPS_staticAdd(BigInteger, BigInteger)

Addiert zwei BigInteger -Werte und gibt das Ergebnis zurück.

System_CAPS_pubmethodSystem_CAPS_staticCompare(BigInteger, BigInteger)

Vergleicht zwei BigInteger -Werte und gibt eine ganze Zahl, die angibt, ob der erste Wert kleiner als, gleich oder größer als der zweite Wert ist.

System_CAPS_pubmethodCompareTo(BigInteger)

Vergleicht diese Instanz mit einer zweiten BigInteger und gibt eine ganze Zahl, die angibt, ob der Wert dieser Instanz kleiner, gleich oder größer als der Wert des angegebenen Objekts zurück.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodSystem_CAPS_staticDivide(BigInteger, BigInteger)

Dividiert einen BigInteger -Wert durch einen anderen und gibt das Ergebnis zurück.

System_CAPS_pubmethodSystem_CAPS_staticDivRem(BigInteger, BigInteger, BigInteger)

Dividiert einen BigInteger Wert durch einen anderen, gibt das Ergebnis zurück und gibt den Rest als Ausgabeparameter zurück.

System_CAPS_pubmethodEquals(BigInteger)

Gibt einen Wert, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger Objekt denselben Wert haben.

System_CAPS_pubmethodEquals(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.

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

System_CAPS_pubmethodEquals(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.

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für das aktuelle BigInteger-Objekt zurück.(Überschreibt ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticGreatestCommonDivisor(BigInteger, BigInteger)

Findet der größte gemeinsame Divisor von zwei BigInteger Werte.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger)

Gibt den natürlichen Logarithmus (zur Basis e) der angegebenen Zahl zurück.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger, Double)

Gibt den Logarithmus einer angegebenen Zahl bezüglich einer angegebenen Basis zurück.

System_CAPS_pubmethodSystem_CAPS_staticLog10(BigInteger)

Gibt den Logarithmus einer angegebenen Zahl zur Basis 10 zurück.

System_CAPS_pubmethodSystem_CAPS_staticMax(BigInteger, BigInteger)

Gibt die größere von zwei BigInteger Werte.

System_CAPS_pubmethodSystem_CAPS_staticMin(BigInteger, BigInteger)

Gibt die kleinere von zwei BigInteger Werte.

System_CAPS_pubmethodSystem_CAPS_staticModPow(BigInteger, BigInteger, BigInteger)

Führt eine Modulodivision für eine zur Potenz einer anderen Zahl erhobene Zahl aus.

System_CAPS_pubmethodSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Gibt das Produkt von zwei BigInteger Werte.

System_CAPS_pubmethodSystem_CAPS_staticNegate(BigInteger)

Negiert einen angegebenen BigInteger Wert.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre BigInteger-Entsprechung um.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die BigInteger-Entsprechung.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die BigInteger-Entsprechung.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticPow(BigInteger, Int32)

Löst ein BigInteger Wert mit einem angegebenen Wert.

System_CAPS_pubmethodSystem_CAPS_staticRemainder(BigInteger, BigInteger)

Führt die Ganzzahldivision von zwei BigInteger Werte und gibt den Rest zurück.

System_CAPS_pubmethodSystem_CAPS_staticSubtract(BigInteger, BigInteger)

Subtrahiert einen BigInteger Wert von einem anderen und gibt das Ergebnis zurück.

System_CAPS_pubmethodToByteArray()

Konvertiert einen BigInteger Wert in ein Bytearray.

System_CAPS_pubmethodToString()

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts in die entsprechende Zeichenfolgendarstellung.(Überschreibt ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

System_CAPS_pubmethodToString(String)

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.

System_CAPS_pubmethodToString(String, IFormatProvider)

Konvertiert den numerischen Wert des aktuellen BigInteger-Objekts unter Verwendung des angegebenen Formats und der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

NameBeschreibung
System_CAPS_puboperatorSystem_CAPS_staticAddition(BigInteger, BigInteger)

Addiert die Werte von zwei angegebenen BigInteger Objekte.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseAnd(BigInteger, BigInteger)

Führt eine bitweise And -Operation für zwei BigInteger Werte.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseOr(BigInteger, BigInteger)

Führt eine bitweise Or -Operation für zwei BigInteger Werte.

System_CAPS_puboperatorSystem_CAPS_staticDecrement(BigInteger)

Dekrementiert den Wert einer BigInteger -Wert um 1.

System_CAPS_puboperatorSystem_CAPS_staticDivision(BigInteger, BigInteger)

Dividiert einen angegebenen BigInteger Wert durch einen anderen angegebenen BigInteger -Wert mit einer Ganzzahldivision.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, BigInteger)

Gibt einen Wert, der angibt, ob die Werte von zwei BigInteger -Objekte gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger -Wert und einen langen Ganzzahlwert mit Vorzeichen gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert und unsigned long Integer-Wert gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticEquality(Int64, BigInteger)

Gibt einen Wert, der angibt, ob signierte long Integer-Wert und ein BigInteger -Wert gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticEquality(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob unsigned long Integer-Wert und ein BigInteger -Wert gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticExclusiveOr(BigInteger, BigInteger)

Führt eine bitweise exklusive Or (XOr)-Operation für zwei BigInteger Werte.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Byte)

Definiert eine explizite Konvertierung von einem BigInteger Objekt in einen Bytewert ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Decimal)

Definiert eine explizite Konvertierung von einem BigInteger -Objekt an eine Decimal Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Double)

Definiert eine explizite Konvertierung von einem BigInteger -Objekt an eine Double Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int16)

Definiert eine explizite Konvertierung von einem BigInteger -Objekt, ein 16-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int32)

Definiert eine explizite Konvertierung von einem BigInteger Objekt ein 32-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int64)

Definiert eine explizite Konvertierung von einem BigInteger -Objekt, ein 64-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to SByte)

Definiert eine explizite Konvertierung von einem BigInteger Objekt in eine 8-Bit-Wert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Single)

Definiert eine explizite Konvertierung von einem BigInteger Objekt in einen Gleitkommawert mit einfacher Genauigkeit.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt16)

Definiert eine explizite Konvertierung von einem BigInteger Objekt, das Wert einer 16-Bit-Ganzzahl ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt32)

Definiert eine explizite Konvertierung von einem BigInteger Objekt auf einen 32-Bit-Ganzzahl ohne Vorzeichen-Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt64)

Definiert eine explizite Konvertierung von einem BigInteger Objekt auf einen 64-Bit-Ganzzahl ohne Vorzeichen-Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Decimal to BigInteger)

Definiert eine explizite Konvertierung von einem Decimal -Objekt an eine BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Double to BigInteger)

Definiert eine explizite Konvertierung einer Double -Wert in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Single to BigInteger)

Definiert eine explizite Konvertierung von einem Single -Objekt an eine BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, BigInteger)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als ein anderes BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger ist größer als 64-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als eine 64-Bit-Ganzzahl ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Int64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als eine 64-Bit-Ganzzahl ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, BigInteger)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als oder gleich einem anderen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als oder gleich einer 64-Bit-Ganzzahlwert mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist größer als oder gleich einer 64-Bit-Ganzzahlwert ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Int64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen größer als oder gleich ist ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen größer oder gleich ist ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Byte to BigInteger)

Definiert eine implizite Konvertierung eines Bytewerts ohne Vorzeichen in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int16 to BigInteger)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl, eine BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int32 to BigInteger)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl, eine BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int64 to BigInteger)

Definiert eine implizite Konvertierung einer signierten 64-Bit-Ganzzahl in eine BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(SByte to BigInteger)

Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl mit Vorzeichen in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt16 to BigInteger)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt32 to BigInteger)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt64 to BigInteger)

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticIncrement(BigInteger)

Inkrementiert einen BigInteger -Wert um 1.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, BigInteger)

Gibt einen Wert zurück, der angibt, ob zwei BigInteger-Objekte über unterschiedliche Werte verfügen.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert und eine 64-Bit-Ganzzahl mit Vorzeichen ungleich sind.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert und eine 64-Bit-Ganzzahl ohne Vorzeichen ungleich sind.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Int64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen und ein BigInteger -Wert ungleich sind.

System_CAPS_puboperatorSystem_CAPS_staticInequality(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen und ein BigInteger -Wert ungleich sind.

System_CAPS_puboperatorSystem_CAPS_staticLeftShift(BigInteger, Int32)

Verschiebt ein BigInteger Wert eine angegebene Anzahl von Bits nach links.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, BigInteger)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner als ein anderes BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner als eine 64-Bit-Ganzzahl mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner als eine 64-Bit-Ganzzahl ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Int64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-ohne Vorzeichen Ganzzahl kleiner als ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, BigInteger)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner als oder gleich einem anderen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, Int64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner oder gleich einer 64-Bit-Ganzzahl mit Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, UInt64)

Gibt einen Wert, der angibt, ob ein BigInteger Wert ist kleiner oder gleich einer 64-Bit-Ganzzahl ohne Vorzeichen.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Int64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl mit Vorzeichen kleiner als oder gleich einem BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(UInt64, BigInteger)

Gibt einen Wert, der angibt, ob eine 64-Bit-Ganzzahl ohne Vorzeichen kleiner als oder gleich einem BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticModulus(BigInteger, BigInteger)

Gibt den Rest aus Division zweier angegebener BigInteger Werte.

System_CAPS_puboperatorSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Multipliziert zwei angegebene BigInteger-Werte.

System_CAPS_puboperatorSystem_CAPS_staticOnesComplement(BigInteger)

Gibt das bitweise Einerkomplement ein BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticRightShift(BigInteger, Int32)

Verschiebt einen BigInteger-Wert um eine angegebene Anzahl von Bits nach rechts.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(BigInteger, BigInteger)

Subtrahiert einen BigInteger Wert von einem anderen BigInteger Wert.

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(BigInteger)

Negiert einen angegebenen BigInteger-Wert.

System_CAPS_puboperatorSystem_CAPS_staticUnaryPlus(BigInteger)

Gibt den Wert der BigInteger Operanden. (Das Vorzeichen des Operanden wird nicht geändert.)

The T:System.Numerics.BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. The members of the T:System.Numerics.BigInteger type closely parallel those of other integral types (the T:System.Byte, T:System.Int16, T:System.Int32, T:System.Int64, T:System.SByte, T:System.UInt16, T:System.UInt32, and T:System.UInt64 types). This type differs from the other integral types in the dnprdnshort, which have a range indicated by their MinValue and MaxValue properties.

System_CAPS_noteHinweis

Because the T:System.Numerics.BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an T:System.OutOfMemoryException can be thrown for any operation that causes a T:System.Numerics.BigInteger value to grow too large.

You can instantiate a T:System.Numerics.BigInteger object in several ways:

  • You can use the new keyword and provide any integral or floating-point value as a parameter to the T:System.Numerics.BigInteger constructor. (Floating-point values are truncated before they are assigned to the T:System.Numerics.BigInteger.) The following example illustrates how to use the new keyword to instantiate T:System.Numerics.BigInteger values.

    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		
    
  • You can declare a T:System.Numerics.BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. The following example uses assignment to create a T:System.Numerics.BigInteger value from an T:System.Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
  • You can assign a decimal or floating-point value to a T:System.Numerics.BigInteger object if you cast the value or convert it first. The following example explicitly casts (in C#) or converts (in Visual Basic) a T:System.Double and a T:System.Decimal value to a T:System.Numerics.BigInteger.

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

These methods enable you to instantiate a T:System.Numerics.BigInteger object whose value is in the range of one of the existing numeric types only. You can instantiate a T:System.Numerics.BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • You can use the new keyword and provide a byte array of any size to the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor. For example:

    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).
    
  • You can call the Overload:System.Numerics.BigInteger.Parse or Overload:System.Numerics.BigInteger.TryParse methods to convert the string representation of a number to a T:System.Numerics.BigInteger. For example:

    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
    
  • You can call a static (Shared in Visual Basic) T:System.Numerics.BigInteger method that performs some operation on a numeric expression and returns a calculated T:System.Numerics.BigInteger result. The following example does this by cubing F:System.UInt64.MaxValue and assigning the result to a T:System.Numerics.BigInteger.

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

The uninitialized value of a T:System.Numerics.BigInteger is P:System.Numerics.BigInteger.Zero.

You can use a T:System.Numerics.BigInteger instance as you would use any other integral type. T:System.Numerics.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. You can also use the standard numeric operators to compare two T:System.Numerics.BigInteger values with each other. Like the other integral types, T:System.Numerics.BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. For languages that do not support custom operators, the T:System.Numerics.BigInteger structure also provides equivalent methods for performing mathematical operations. These include M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger), M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger), and several others.

Many members of the T:System.Numerics.BigInteger structure correspond directly to members of the other integral types. In addition, T:System.Numerics.BigInteger adds members such as the following:

  • Sign, which returns a value that indicates the sign of a BigInteger value.

  • Abs, which returns the absolute value of a BigInteger value.

  • DivRem, which returns both the quotient and remainder of a division operation.

  • GreatestCommonDivisor, which returns the greatest common divisor of two BigInteger values.

Many of these additional members correspond to the members of the T:System.Math class, which provides the functionality to work with the primitive numeric types.

The following example instantiates a T:System.Numerics.BigInteger object and then increments its value by one.

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

Although this example appears to modify the value of the existing object, this is not the case. T:System.Numerics.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new T:System.Numerics.BigInteger object and assigns it a value one greater than its previous value. This new object is then returned to the caller.

System_CAPS_noteHinweis

The other numeric types in the .NET Framework are also immutable. However, because the T:System.Numerics.BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Although this process is transparent to the caller, it does incur a performance penalty. In some cases, especially when repeated operations are performed in a loop on very large T:System.Numerics.BigInteger values, that performance penalty can be significant. For example, in the following example, an operation is performed repetitively up to a million times, and a T:System.Numerics.BigInteger value is incremented by one every time the operation succeeds.

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 such a case, you can improve performance by performing all intermediate assignments to an T:System.Int32 variable. The final value of the variable can then be assigned to the T:System.Numerics.BigInteger object when the loop exits. The following example provides an illustration.

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;

If you convert T:System.Numerics.BigInteger values to byte arrays, or if you convert byte arrays to T:System.Numerics.BigInteger values, you must consider the order of bytes. The T:System.Numerics.BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). You can round-trip a T:System.Numerics.BigInteger value by calling the M:System.Numerics.BigInteger.ToByteArray method and then passing the resulting byte array to the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor, as the following example shows.

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

To instantiate a T:System.Numerics.BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the M:System.BitConverter.GetBytes(System.UInt16) method, and then pass the resulting byte array to the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor. The following example instantiates a T:System.Numerics.BigInteger value from a byte array that represents an T:System.Int16 value.

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

The T:System.Numerics.BigInteger structure assumes that negative values are stored by using two's complement representation. Because the T:System.Numerics.BigInteger structure represents a numeric value with no fixed length, the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. To prevent the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor as -1,000,000. To instantiate a T:System.Numerics.BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. The following example illustrates this.

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      

Byte arrays created by the M:System.Numerics.BigInteger.ToByteArray method from positive values include this extra zero-value byte. Therefore, the T:System.Numerics.BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

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

However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as M:System.BitConverter.GetBytes(System.UInt16), M:System.BitConverter.GetBytes(System.UInt32), and M:System.BitConverter.GetBytes(System.UInt64)).

When parsing a hexadecimal string, the M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles) and M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. For example, both "FF01" and "F01" represent the decimal value -255. To differentiate positive from negative values, positive values should include a leading zero. The relevant overloads of the M:System.Numerics.BigInteger.ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. This makes it possible to round-trip T:System.Numerics.BigInteger values by using the M:System.Numerics.BigInteger.ToString and M:System.Numerics.BigInteger.Parse(System.String) methods, as the following example shows.

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.

However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the M:System.Convert.ToString(System.Int32) method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. Successfully instantiating a T:System.Numerics.BigInteger value from such a string requires some additional logic. The following example provides one possible implementation.

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.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 4.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 4.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: