Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura BigInteger

 

Publicado: noviembre de 2016

Representa un entero con signo arbitrariamente grande.

Espacio de nombres:   System.Numerics
Ensamblado:  System.Numerics (en System.Numerics.dll)

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

NombreDescripción
System_CAPS_pubmethodBigInteger(Byte[])

Inicializa una nueva instancia de la estructura BigInteger utilizando los valores de una matriz de bytes.

System_CAPS_pubmethodBigInteger(Decimal)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor Decimal.

System_CAPS_pubmethodBigInteger(Double)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión doble.

System_CAPS_pubmethodBigInteger(Int32)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 32 bits con signo.

System_CAPS_pubmethodBigInteger(Int64)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 64 bits con signo.

System_CAPS_pubmethodBigInteger(Single)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión sencilla.

System_CAPS_pubmethodBigInteger(UInt32)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor entero de 32 bits sin signo.

System_CAPS_pubmethodBigInteger(UInt64)

Inicializa una nueva instancia de la estructura BigInteger con un valor entero de 64 bits sin signo.

NombreDescripción
System_CAPS_pubpropertyIsEven

Indica si el valor del objeto BigInteger actual es un número par.

System_CAPS_pubpropertyIsOne

Indica si el valor del objeto BigInteger actual es BigInteger.One.

System_CAPS_pubpropertyIsPowerOfTwo

Indica si el valor del objeto BigInteger actual es una potencia de dos.

System_CAPS_pubpropertyIsZero

Indica si el valor del objeto BigInteger actual es BigInteger.Zero.

System_CAPS_pubpropertySystem_CAPS_staticMinusOne

Obtiene un valor que representa menos uno (-1).

System_CAPS_pubpropertySystem_CAPS_staticOne

Obtiene un valor que representa el número uno (1).

System_CAPS_pubpropertySign

Obtiene un número que indica el signo (negativo, positivo o cero) del objeto BigInteger actual.

System_CAPS_pubpropertySystem_CAPS_staticZero

Obtiene un valor que representa el número 0 (cero).

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticAbs(BigInteger)

Obtiene el valor absoluto de un objeto BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticAdd(BigInteger, BigInteger)

Suma dos valores BigInteger y devuelve el resultado.

System_CAPS_pubmethodSystem_CAPS_staticCompare(BigInteger, BigInteger)

Compara dos valores BigInteger y devuelve un entero que indica si el primer valor es menor, igual o mayor que el segundo.

System_CAPS_pubmethodCompareTo(BigInteger)

Compara esta instancia con un segundo BigInteger y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del objeto especificado.

System_CAPS_pubmethodCompareTo(Int64)

Compara esta instancia con un entero de 64 bits con signo y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del entero de 64 bits con signo.

System_CAPS_pubmethodCompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es mayor, igual o menor que el valor del objeto especificado.

System_CAPS_pubmethodCompareTo(UInt64)

Compara esta instancia con un entero de 64 bits sin signo y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del entero de 64 bits sin signo.

System_CAPS_pubmethodSystem_CAPS_staticDivide(BigInteger, BigInteger)

Divide un valor BigInteger por otro y devuelve el resultado.

System_CAPS_pubmethodSystem_CAPS_staticDivRem(BigInteger, BigInteger, BigInteger)

Divide un valor BigInteger por otro, devuelve el resultado y devuelve el resto en un parámetro de salida.

System_CAPS_pubmethodEquals(BigInteger)

Devuelve un valor que indica si la instancia actual y un objeto BigInteger especificado tienen el mismo valor.

System_CAPS_pubmethodEquals(Int64)

Devuelve un valor que indica si la instancia actual y un entero de 64 bits con signo tienen el mismo valor.

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodEquals(UInt64)

Devuelve un valor que indica si la instancia actual y un entero de 64 bits sin signo tienen el mismo valor.

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash del objeto BigInteger actual.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticGreatestCommonDivisor(BigInteger, BigInteger)

Busca el máximo común divisor de dos valores BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger)

Devuelve el logaritmo natural (en base e) de un número especificado.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger, Double)

Devuelve el logaritmo de un número especificado en una base determinada.

System_CAPS_pubmethodSystem_CAPS_staticLog10(BigInteger)

Devuelve el logaritmo en base 10 de un número especificado.

System_CAPS_pubmethodSystem_CAPS_staticMax(BigInteger, BigInteger)

Devuelve el mayor de dos valores BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticMin(BigInteger, BigInteger)

Devuelve el menor de dos valores BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticModPow(BigInteger, BigInteger, BigInteger)

Realiza una división de módulo en un número elevado a la potencia de otro número.

System_CAPS_pubmethodSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Devuelve el producto de dos valores BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticNegate(BigInteger)

Crea el negativo de un valor BigInteger especificado.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convierte la representación en forma de cadena de un número en su BigInteger equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Convierte la representación de la cadena de un número en un formato específico de la referencia cultural indicada en su equivalente de BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Convierte la representación de cadena de un número con un estilo especificado en su BigInteger equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticPow(BigInteger, Int32)

Eleva un valor BigInteger a la potencia del valor especificado.

System_CAPS_pubmethodSystem_CAPS_staticRemainder(BigInteger, BigInteger)

Realiza la división entera en dos valores BigInteger y devuelve el resto.

System_CAPS_pubmethodSystem_CAPS_staticSubtract(BigInteger, BigInteger)

Resta un valor BigInteger de otro y devuelve el resultado.

System_CAPS_pubmethodToByteArray()

Convierte un valor BigInteger en una matriz de bytes.

System_CAPS_pubmethodToString()

Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente.(Invalida ValueType.ToString()).

System_CAPS_pubmethodToString(IFormatProvider)

Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente usando la información de formato específica de la referencia cultural indicada.

System_CAPS_pubmethodToString(String)

Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente con el formato especificado.

System_CAPS_pubmethodToString(String, IFormatProvider)

Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente usando el formato especificado y la información de formato específica de la referencia cultural.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, BigInteger)

Intenta convertir la representación de cadena de un número en si equivalente de BigInteger y devuelve un valor que indica si la conversión tuvo éxito.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, BigInteger)

Intenta convertir la representación de cadena de un número con un estilo específico y un formato específico de la referencia cultural en su equivalente de BigInteger y devuelve un valor que indica si la conversión fue correcta.

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticAddition(BigInteger, BigInteger)

Suma los valores de dos objetos BigInteger especificados.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseAnd(BigInteger, BigInteger)

Realiza una operación And bit a bit en dos valores BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseOr(BigInteger, BigInteger)

Realiza una operación Or bit a bit en dos valores BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticDecrement(BigInteger)

Disminuye un valor BigInteger en 1.

System_CAPS_puboperatorSystem_CAPS_staticDivision(BigInteger, BigInteger)

Divide un valor BigInteger especificado por otro valor BigInteger indicado utilizando división de enteros.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, BigInteger)

Devuelve un valor que indica si los valores de dos objetos BigInteger son iguales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger y un valor entero long con signo son iguales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger y un valor entero long sin signo son iguales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(Int64, BigInteger)

Devuelve un valor que indica si un valor entero long con signo y un valor BigInteger son iguales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(UInt64, BigInteger)

Devuelve un valor que indica si un valor entero long sin signo y un valor BigInteger son iguales.

System_CAPS_puboperatorSystem_CAPS_staticExclusiveOr(BigInteger, BigInteger)

Realiza una operación exclusiva Or (XOr) bit a bit en dos valores BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Byte)

Define una conversión explícita de un objeto BigInteger en un valor de byte sin signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Decimal)

Define una conversión explícita de un objeto BigInteger en un valor Decimal.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Double)

Define una conversión explícita de un objeto BigInteger en un valor Double.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int16)

Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int32)

Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int64)

Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to SByte)

Define una conversión explícita de un objeto BigInteger en un valor de 8 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Single)

Define una conversión explícita de un objeto BigInteger en un valor de punto flotante de precisión sencilla.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt16)

Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt32)

Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt64)

Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Decimal to BigInteger)

Define una conversión explícita de un objeto Decimal en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Double to BigInteger)

Define una conversión explícita de un valor Double en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Single to BigInteger)

Define una conversión explícita de un objeto Single en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, BigInteger)

Devuelve un valor que indica si un valor BigInteger es mayor que otro valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger es mayor que un valor entero de 64 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger es mayor que un entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Int64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits con signo es mayor que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(UInt64, BigInteger)

Devuelve un valor que indica si un valor BigInteger es mayor que un entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, BigInteger)

Devuelve un valor que indica si un valor BigInteger es mayor o igual que otro valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger es mayor o igual que un valor entero de 64 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger es mayor o igual que un valor entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Int64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits con signo es mayor o igual que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(UInt64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits sin signo es mayor o igual que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Byte to BigInteger)

Define una conversión implícita de un byte sin signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int16 to BigInteger)

Define una conversión implícita de un entero de 16 bits con signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int32 to BigInteger)

Define una conversión implícita de un entero de 32 bits con signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int64 to BigInteger)

Define una conversión implícita de un entero de 64 bits con signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(SByte to BigInteger)

Define una conversión implícita de un entero de 8 bits con signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt16 to BigInteger)

Define una conversión implícita de un entero de 16 bits sin signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt32 to BigInteger)

Define una conversión implícita de un entero de 32 bits sin signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt64 to BigInteger)

Define una conversión implícita de un entero de 64 bits sin signo en un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticIncrement(BigInteger)

Aumenta un valor BigInteger en 1.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, BigInteger)

Devuelve un valor que indica si dos objetos BigInteger tienen valores diferentes.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger y un valor de 64 bits con signo no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger y un valor de 64 bits sin signo no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Int64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits con signo y un valor BigInteger no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(UInt64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits sin signo y un valor BigInteger no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticLeftShift(BigInteger, Int32)

Desplaza un valor BigInteger un número especificado de bits a la izquierda.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, BigInteger)

Devuelve un valor que indica si un valor BigInteger es menor que otro valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger es menor que un entero de 64 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger es menor que un entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Int64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits con signo es menor que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(UInt64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits sin signo es menor que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, BigInteger)

Devuelve un valor que indica si un valor BigInteger es menor o igual que otro valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, Int64)

Devuelve un valor que indica si un valor BigInteger es menor o igual que un entero de 64 bits con signo.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, UInt64)

Devuelve un valor que indica si un valor BigInteger es menor o igual que un entero de 64 bits sin signo.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Int64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits con signo es menor o igual que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(UInt64, BigInteger)

Devuelve un valor que indica si un entero de 64 bits sin signo es menor o igual que un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticModulus(BigInteger, BigInteger)

Devuelve el resto que se obtiene al dividir dos valores BigInteger especificados.

System_CAPS_puboperatorSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Multiplica dos valores BigInteger especificados.

System_CAPS_puboperatorSystem_CAPS_staticOnesComplement(BigInteger)

Devuelve el complemento de uno bit a bit de un valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticRightShift(BigInteger, Int32)

Desplaza un valor BigInteger un número especificado de bits a la derecha.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(BigInteger, BigInteger)

Resta un valor BigInteger de otro valor BigInteger.

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(BigInteger)

Crea el negativo de un valor BigInteger especificado.

System_CAPS_puboperatorSystem_CAPS_staticUnaryPlus(BigInteger)

Devuelve el valor del operando BigInteger. (El signo del operando no cambia).

El BigInteger tipo es un tipo inmutable que representa un entero arbitrariamente grande cuyo valor en teoría no tiene ningún límite superior o inferior. Los miembros de la BigInteger tipo análogos a los de otros tipos integrales (el Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, y UInt64 tipos). Este tipo difiere de otros tipos integrales en el .NET Framework, que tiene un intervalo indicado por sus MinValue y MaxValue Propiedades.

System_CAPS_noteNota

Porque el BigInteger tipo es inmutable (vea mutabilidad y la estructura BigInteger) y porque no tiene ningún límite superior o inferior, un OutOfMemoryException puede producir para cualquier operación que provoca un BigInteger valor aumente demasiado.

Puede crear instancias de un BigInteger objeto de varias maneras:

  • Puede usar el new (palabra clave) y proporcione cualquier valor entero o de punto flotante como un parámetro a la BigInteger constructor. (Valores de punto flotante se truncan antes de que se asignan a la BigInteger.) En el ejemplo siguiente se muestra cómo utilizar el new palabra clave que se va a crear una instancia de BigInteger valores.

    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		
    
  • Puede declarar un BigInteger variable y asignarle un valor como lo haría con cualquier tipo numérico, siempre que ese valor es un tipo entero. En el ejemplo siguiente se utiliza la asignación para crear un BigInteger valor desde un Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
  • Puede asignar un valor decimal o de punto flotante a un BigInteger objeto si convierte el valor o lo convierte primero. En el ejemplo siguiente se convierte (en C#) explícitamente o se convierte (en Visual Basic) un Double y un Decimal valor a un 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      
    

Estos métodos permiten crear instancias de un BigInteger solo tipos de objeto cuyo valor se encuentra en el intervalo de uno del valor numérico existente. Puede crear instancias de un BigInteger objeto cuyo valor puede superar el intervalo de los tipos numéricos existentes en una de tres maneras:

  • Puede usar el new (palabra clave) y proporcionar una matriz de bytes de cualquier tamaño la BigInteger.BigInteger constructor. Por ejemplo:

    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).
    
  • Puede llamar a la Parse o TryParse métodos para convertir la representación de cadena de un número en un BigInteger. Por ejemplo:

    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
    
  • Puede llamar a un static (Shared en Visual Basic) BigInteger método que realiza alguna operación en una expresión numérica y devuelve un calculado BigInteger resultado. En el ejemplo siguiente se hace esto elevando UInt64.MaxValue y asignar el resultado a un BigInteger.

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

El valor sin inicializar de un BigInteger es Zero.

Puede usar un BigInteger como utilizaría cualquier otro tipo integral de la instancia. BigInteger sobrecargas de los operadores numéricos estándar para permitirle realizar operaciones matemáticas básicas como suma, resta, división, multiplicación, resta, negación y negación unaria. También puede utilizar los operadores numéricos estándar para comparar dos BigInteger valores entre sí. Al igual que otros tipos integrales, BigInteger también admite el bit a bit And, Or, XOr, izquierda MAYÚS y operadores de desplazamiento a la derecha. Para los lenguajes que no admiten operadores personalizados, la BigInteger estructura también proporciona métodos equivalentes para realizar operaciones matemáticas. Entre ellos se incluyen Add, Divide, Multiply, Negate, Subtract, entre otras.

Muchos miembros de la BigInteger estructura corresponden directamente a los miembros de otros tipos integrales. Además, BigInteger agrega miembros como los siguientes:

  • Sign, que devuelve un valor que indica el signo de un BigInteger valor.

  • Abs, que devuelve el valor absoluto de un BigInteger valor.

  • DivRem, que devuelve el cociente y el resto de una operación de división.

  • GreatestCommonDivisor, que devuelve el máximo común divisor de dos BigInteger valores.

Muchos de estos miembros adicionales se corresponden a los miembros de la Math clase, que proporciona la funcionalidad para trabajar con los tipos numéricos primitivos.

En el ejemplo siguiente se crea un BigInteger de objetos y, a continuación, aumenta su valor en uno.

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

Aunque este ejemplo parece modificar el valor del objeto existente, no es el caso. BigInteger los objetos son inmutables, lo que significa que internamente, common language runtime crea en realidad un nuevo BigInteger objeto y le asigna un valor mayor que su valor anterior. Este nuevo objeto, a continuación, se devuelve al llamador.

System_CAPS_noteNota

Los demás tipos numéricos en .NET Framework también son inmutables. Sin embargo, dado que el BigInteger tipo no tiene ningún límite superior o inferior, sus valores pueden llegar a ser muy grandes y tener un impacto apreciable en el rendimiento.

Aunque este proceso es transparente para el llamador, incurre en una reducción del rendimiento. En algunos casos, especialmente cuando las operaciones repetidas se realizan en un bucle en gran BigInteger valores, esa disminución del rendimiento puede ser considerable. Por ejemplo, en el ejemplo siguiente, se realiza una operación repetidamente hasta un millón de veces y un BigInteger valor se incrementa en uno cada vez que la operación se realiza correctamente.

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++;
}

En tal caso, puede mejorar el rendimiento realizando todos los trabajos intermedios en una Int32 variable. El valor final de la variable, a continuación, puede asignarse a la BigInteger objeto cuando se sale del bucle. Esto se muestra en el ejemplo siguiente.

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;

Si convierte BigInteger valores a las matrices de bytes, o si convierte las matrices de bytes a BigInteger valores, debe considerar el orden de bytes. El BigInteger estructura espera los bytes individuales en una matriz de bytes que aparecen en orden little-endian (es decir, los bytes de orden inferior del valor preceden a los bytes de orden superior). Puede acudir un BigInteger valor llamando el ToByteArray método y, a continuación, pasa el byte resultante de matriz para el BigInteger(Byte[]) constructor, como se muestra en el ejemplo siguiente.

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

Para crear instancias de un BigInteger valor desde una matriz de bytes que representa un valor de algún otro tipo integral, puede pasar el valor entero para la BitConverter.GetBytes método y, a continuación, pasa el byte resultante de matriz para el BigInteger(Byte[]) constructor. En el ejemplo siguiente se crea un BigInteger el valor de una matriz de bytes que representa un Int16 valor.

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

El BigInteger estructura se supone que los valores negativos se almacenan utilizando dos representación del complemento. Dado que el BigInteger estructura representa un valor numérico sin longitud fija, el BigInteger(Byte[]) constructor siempre interpreta el bit más significativo del último byte de la matriz como un bit de signo. Para evitar la BigInteger(Byte[]) constructor confunda la representación complementaria de dos de un valor negativo con la representación de signo y magnitud de un valor positivo, positivo en el que el bit más significativo del último byte en la matriz de bytes normalmente sería un conjunto de valores deben incluir un byte adicional cuyo valor es 0. Por ejemplo, 0xC0 0xBD 0xF0 0xFF es la representación hexadecimal de little-endian de -1.000.000 o 4.293.967.296. Dado el bit más significativo del último byte en esta matriz está activado, el valor de la matriz de bytes se interpretaría por la BigInteger(Byte[]) constructor como -1.000.000. Para crear instancias de un BigInteger cuyo valor es positivo, una matriz de bytes cuyos elementos son 0xC0 0xBD 0xF0 0xFF 0x00 se debe pasar al constructor. Esto se ilustra en el siguiente ejemplo:

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      

Matrices de bytes creadas por el ToByteArray método desde los valores positivos incluyen este byte del valor cero adicional. Por lo tanto, la BigInteger estructura puede valores de ida y vuelta correctamente asignándolos a y, a continuación, restaurarlos desde matrices de bytes, como se muestra en el ejemplo siguiente.

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

Sin embargo, debe agregar este byte del valor cero adicional a las matrices de bytes que se crean dinámicamente por el desarrollador o que devuelven los métodos que convierten los enteros sin signo en matrices de bytes (como BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), y BitConverter.GetBytes(UInt64)).

Al analizar una cadena hexadecimal, el BigInteger.Parse(String, NumberStyles) y BigInteger.Parse(String, NumberStyles, IFormatProvider) métodos suponen que si se establece el bit más significativo del primer byte de la cadena, o si el primer dígito hexadecimal de la cadena representa los cuatro bits inferiores de un valor de byte, el valor se representa utilizando la representación complementaria de dos. Por ejemplo, "FF01" y "F01" representan el valor decimal -255. Para diferenciar positivo de los valores negativos, los valores positivos deberían incluir un cero inicial. Las sobrecargas pertinentes de la ToString método, cuando se pasan la cadena de formato "X", agregan un cero inicial a la cadena hexadecimal devuelta para los valores positivos. Esto hace posible que acudir BigInteger valores usando el ToString y Parse métodos, como se muestra en el ejemplo siguiente.

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.

Sin embargo, las cadenas hexadecimales se crean mediante una llamada a la ToString métodos de los demás tipos enteros o de las sobrecargas de los ToString método que incluyen un toBase parámetro no indican el signo del valor o el tipo de datos de origen desde el que se derivó la cadena hexadecimal. Crear instancias de correctamente un BigInteger el valor de esta cadena requiere alguna lógica adicional. En el ejemplo siguiente se proporciona una implementación posible.

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.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 4.0
Windows Phone
Disponible desde 8.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: