BigInteger Constructores

Definición

Inicializa una nueva instancia de la estructura BigInteger .Initializes a new instance of the BigInteger structure.

Sobrecargas

BigInteger(Byte[])

Inicializa una nueva instancia de la estructura BigInteger utilizando los valores de una matriz de bytes.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión doble.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 32 bits con signo.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 64 bits con signo.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión sencilla.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor entero de 32 bits sin signo.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

Inicializa una nueva instancia de la estructura BigInteger con un valor entero de 64 bits sin signo.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inicializa una nueva instancia de la estructura BigInteger mediante los valores de un intervalo de solo lectura de bytes y, de forma opcional, indica la codificación de firma y el orden de bytes endianness.Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.

BigInteger(Byte[])

Importante

Esta API no es conforme a CLS.

Inicializa una nueva instancia de la estructura BigInteger utilizando los valores de una matriz de bytes.Initializes a new instance of the BigInteger structure using the values in a byte array.

public:
 BigInteger(cli::array <System::Byte> ^ value);
[System.CLSCompliant(false)]
public BigInteger (byte[] value);
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger
Public Sub New (value As Byte())

Parámetros

value
Byte[]

Matriz de valores de byte en orden little-endian.An array of byte values in little-endian order.

Atributos

Excepciones

value es null.value is null.

Ejemplos

En el ejemplo siguiente se crea una instancia de un objeto BigInteger a partir de una matriz de bytes de 5 elementos cuyo valor es {5, 4, 3, 2, 1}.The following example instantiates a BigInteger object from a 5-element byte array whose value is {5, 4, 3, 2, 1}. A continuación, muestra el valor BigInteger, representado como números decimales y hexadecimales, en la consola.It then displays the BigInteger value, represented as both decimal and hexadecimal numbers, to the console. Una comparación de la matriz de entrada con la salida de texto deja claro por qué esta sobrecarga del constructor de clase BigInteger crea un objeto BigInteger cuyo valor es 4328719365 (o 0x102030405).A comparison of the input array with the text output makes it clear why this overload of the BigInteger class constructor creates a BigInteger object whose value is 4328719365 (or 0x102030405). El primer elemento de la matriz de bytes, cuyo valor es 5, define el valor del byte de orden inferior del objeto BigInteger, que es 0x05.The first element of the byte array, whose value is 5, defines the value of the lowest-order byte of the BigInteger object, which is 0x05. El segundo elemento de la matriz de bytes, cuyo valor es 4, define el valor del segundo byte del objeto BigInteger, que es 0x04, etc.The second element of the byte array, whose value is 4, defines the value of the second byte of the BigInteger object, which is 0x04, and so on.

byte[] bytes = { 5, 4, 3, 2, 1 };
BigInteger number = new BigInteger(bytes);
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number); 
// The example displays the following output:
//    The value of number is 4328719365 (or 0x102030405).   
Dim bytes() As Byte = { 5, 4, 3, 2, 1 }
Dim number As New BigInteger(bytes)
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number) 
' The example displays the following output:
'    The value of number is 4328719365 (or 0x102030405).   

En el ejemplo siguiente se crean instancias de un valor de BigInteger positivo y negativo, se pasan al método ToByteArray y, a continuación, se restauran los valores de BigInteger originales de la matriz de bytes resultante.The following example instantiates a positive and a negative BigInteger value, passes them to the ToByteArray method, and then restores the original BigInteger values from the resulting byte array. Tenga en cuenta que los dos valores se representan mediante matrices de bytes idénticas.Note that the two values are represented by identical byte arrays. La única diferencia entre ellos es el bit más significativo del último elemento de la matriz de bytes.The only difference between them is in the most significant bit of the last element in the byte array. Este bit se establece (el valor del byte es 0xFF) si la matriz se crea a partir de un valor de BigInteger negativo.This bit is set (the value of the byte is 0xFF) if the array is created from a negative BigInteger value. No se establece el bit (el valor de byte es cero) si la matriz se crea a partir de un valor de BigInteger positivo.The bit is not set (the value of the byte is zero), if the array is created from a positive BigInteger value.

// Instantiate BigInteger values.
BigInteger positiveValue = BigInteger.Parse("4713143110832790377889");
BigInteger negativeValue = BigInteger.Add(-Int64.MaxValue, -60000); 
BigInteger positiveValue2, negativeValue2;

// Create two byte arrays.
byte[] positiveBytes = positiveValue.ToByteArray();
byte[] negativeBytes = negativeValue.ToByteArray();

// Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue);
foreach (byte byteValue in negativeBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue2 = new BigInteger(negativeBytes);
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2);
Console.WriteLine();

// Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue);
foreach (byte byteValue in positiveBytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue2 = new BigInteger(positiveBytes);
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2);
Console.WriteLine();
// The example displays the following output:
//    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
//    Converted the byte array to -9,223,372,036,854,835,807
//    
//    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
//    Converted the byte array to 4,713,143,110,832,790,377,889
' Instantiate BigInteger values.
Dim positiveValue As BigInteger = BigInteger.Parse("4713143110832790377889")
Dim negativeValue As BigInteger = BigInteger.Add(-Int64.MaxValue, -60000) 
Dim positiveValue2, negativeValue2 As BigInteger

' Create two byte arrays.
Dim positiveBytes() As Byte = positiveValue.ToByteArray()
Dim negativeBytes() As Byte = negativeValue.ToByteArray()

' Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue)
For Each byteValue As Byte In negativeBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
negativeValue2 = New BigInteger(negativeBytes)
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2)
Console.WriteLine()

' Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue)
For Each byteValue As Byte In positiveBytes
   Console.Write("{0:X2} ", byteValue)
Next 
Console.WriteLine()
positiveValue2 = New BigInteger(positiveBytes)
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2)
Console.WriteLine()
' The example displays the following output:
'    Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
'    Converted the byte array to -9,223,372,036,854,835,807
'    
'    Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
'    Converted the byte array to 4,713,143,110,832,790,377,889

En el ejemplo siguiente se muestra cómo asegurarse de que no se crea una instancia incorrecta de un valor positivo como un valor negativo agregando un byte cuyo valor es cero al final de la matriz.The following example illustrates how to make sure that a positive value is not incorrectly instantiated as a negative value by adding a byte whose value is zero to the end of the array.

ulong originalNumber = UInt64.MaxValue;
byte[] bytes = BitConverter.GetBytes(originalNumber);
if (originalNumber > 0 && (bytes[bytes.Length - 1] & 0x80) > 0) 
{
   byte[] temp = new byte[bytes.Length];
   Array.Copy(bytes, temp, bytes.Length);
   bytes = new byte[temp.Length + 1];
   Array.Copy(temp, bytes, temp.Length);
}

BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.", 
                  originalNumber, newNumber); 
// The example displays the following output:
//    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.
Dim originalNumber As ULong = UInt64.MaxValue
' Convert an unsigned integer to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalNumber)
' Determine whether the MSB of the highest-order byte is set.
If originalNumber > 0 And (bytes(bytes.Length - 1) And &h80) > 0 Then
   ' If the MSB is set, add one zero-value byte to the end of the array.
   ReDim Preserve bytes(bytes.Length)
End If

Dim newNumber As New BigInteger(bytes)
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.", 
                  originalNumber, newNumber) 
' The example displays the following output:
'    Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.

Comentarios

Los bytes individuales de la matriz de value deben estar en orden Little-endian, desde el byte de orden inferior hasta el byte de orden superior.The individual bytes in the value array should be in little-endian order, from lowest-order byte to highest-order byte. Por ejemplo, el valor numérico 1 billón se representa como se muestra en la tabla siguiente:For example, the numeric value 1,000,000,000,000 is represented as shown in the following table:

Cadena hexadecimalHexadecimal string E8D4A51000E8D4A51000
Matriz de bytes (índice más bajo primero)Byte array (lowest index first) 00 10 A5 D4 E8 0000 10 A5 D4 E8 00

La mayoría de los métodos que convierten valores numéricos en matrices de bytes, como BigInteger.ToByteArray y BitConverter.GetBytes, devuelven las matrices de bytes en orden Little-Endian.Most methods that convert numeric values to byte arrays, such as BigInteger.ToByteArray and BitConverter.GetBytes, return byte arrays in little-endian order.

El constructor espera valores positivos en la matriz de bytes para usar la representación de signo y magnitud, y valores negativos para usar la representación del complemento de dos.The constructor expects positive values in the byte array to use sign-and-magnitude representation, and negative values to use two's complement representation. En otras palabras, si se establece el bit de orden superior del byte de orden superior de value, el valor de BigInteger resultante es negativo.In other words, if the highest-order bit of the highest-order byte in value is set, the resulting BigInteger value is negative. Dependiendo del origen de la matriz de bytes, esto puede hacer que un valor positivo se interprete erróneamente como un valor negativo.Depending on the source of the byte array, this may cause a positive value to be misinterpreted as a negative value. Las matrices de bytes se generan normalmente de las siguientes maneras:Byte arrays are typically generated in the following ways:

  • Llamando al método BigInteger.ToByteArray.By calling the BigInteger.ToByteArray method. Dado que este método devuelve una matriz de bytes con el bit de orden superior del byte de orden superior de la matriz establecida en cero para los valores positivos, no existe la posibilidad de interpretar erróneamente un valor positivo como negativo.Because this method returns a byte array with the highest-order bit of the highest-order byte in the array set to zero for positive values, there is no chance of misinterpreting a positive value as negative. Las matrices de bytes no modificadas creadas por el método ToByteArray siempre realizan correctamente el recorrido de ida y vuelta cuando se pasan al constructor BigInteger(Byte[]).Unmodified byte arrays created by the ToByteArray method always successfully round-trip when they are passed to the BigInteger(Byte[]) constructor.

  • Llamando al método BitConverter.GetBytes y pasándole un entero con signo como parámetro.By calling the BitConverter.GetBytes method and passing it a signed integer as a parameter. Dado que los enteros con signo controlan la representación de signo y magnitud y la representación del complemento de dos, no existe la posibilidad de interpretar erróneamente un valor positivo como negativo.Because signed integers handle both sign-and-magnitude representation and two's complement representation, there is no chance of misinterpreting a positive value as negative.

  • Llamando al método BitConverter.GetBytes y pasándole un entero sin signo como parámetro.By calling the BitConverter.GetBytes method and passing it an unsigned integer as a parameter. Dado que los enteros sin signo se representan por su magnitud únicamente, los valores positivos se pueden interpretar erróneamente como valores negativos.Because unsigned integers are represented by their magnitude only, positive values can be misinterpreted as negative values. Para evitar esta interpretación errónea, puede Agregar un valor de cero bytes al final de la matriz.To prevent this misinterpretation, you can add a zero-byte value to the end of the array. En el ejemplo de la sección siguiente se proporciona una ilustración.The example in the next section provides an illustration.

  • Mediante la creación de una matriz de bytes de forma dinámica o estática sin llamar necesariamente a ninguno de los métodos anteriores o mediante la modificación de una matriz de bytes existente.By creating a byte array either dynamically or statically without necessarily calling any of the previous methods, or by modifying an existing byte array. Para evitar que los valores positivos se interpreten erróneamente como valores negativos, puede Agregar un valor de cero bytes al final de la matriz.To prevent positive values from being misinterpreted as negative values, you can add a zero-byte value to the end of the array.

Si value es una matriz de Byte vacía, el nuevo objeto de BigInteger se inicializa en un valor de BigInteger.Zero.If value is an empty Byte array, the new BigInteger object is initialized to a value of BigInteger.Zero. Si se null``value, el constructor inicia una ArgumentNullException.If value is null, the constructor throws an ArgumentNullException.

Consulte también:

BigInteger(Decimal)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

public:
 BigInteger(System::Decimal value);
public BigInteger (decimal value);
new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger
Public Sub New (value As Decimal)

Parámetros

value
Decimal

Un número decimal.A decimal number.

Ejemplos

En el ejemplo siguiente se muestra el uso del constructor BigInteger(Decimal) para crear una instancia de un objeto BigInteger.The following example illustrates the use of the BigInteger(Decimal) constructor to instantiate a BigInteger object. Define una matriz de valores Decimal y, a continuación, pasa cada valor al constructor BigInteger(Decimal).It defines an array of Decimal values, and then passes each value to the BigInteger(Decimal) constructor. Tenga en cuenta que el valor Decimal se trunca en lugar de redondearse cuando se asigna al objeto BigInteger.Note that the Decimal value is truncated instead of rounded when it is assigned to the BigInteger object.

decimal[] decimalValues = { -1790.533m, -15.1514m, 18903.79m, 9180098.003m };
foreach (decimal decimalValue in decimalValues)
{
   BigInteger number = new BigInteger(decimalValue);
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue);
}                 
// The example displays the following output:
//    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
//    Instantiated BigInteger value -15 from the Decimal value -15.1514.
//    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
//    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.
Dim decimalValues() As Decimal = { -1790.533d, -15.1514d, 18903.79d, 9180098.003d }
For Each decimalValue As Decimal In decimalValues
   Dim number As New BigInteger(decimalValue)
   Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
                     number, decimalValue)
Next                 
' The example displays the following output:
'    Instantiated BigInteger value -1790 from the Decimal value -1790.533.
'    Instantiated BigInteger value -15 from the Decimal value -15.1514.
'    Instantiated BigInteger value 18903 from the Decimal value 18903.79.
'    Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.

Comentarios

El resultado de llamar a este constructor es idéntico a asignar explícitamente un valor de Decimal a una variable de BigInteger.The result of calling this constructor is identical to explicitly assigning a Decimal value to a BigInteger variable.

La llamada a este constructor puede provocar la pérdida de datos; cualquier parte fraccionaria de value se trunca al crear una instancia de un objeto BigInteger.Calling this constructor can cause data loss; any fractional part of value is truncated when instantiating a BigInteger object.

BigInteger(Double)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión doble.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

public:
 BigInteger(double value);
public BigInteger (double value);
new System.Numerics.BigInteger : double -> System.Numerics.BigInteger
Public Sub New (value As Double)

Parámetros

value
Double

Un valor de punto flotante y precisión doble.A double-precision floating-point value.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra el uso del constructor BigInteger(Double) para crear una instancia de un objeto BigInteger.The following example illustrates the use of the BigInteger(Double) constructor to instantiate a BigInteger object. También se muestra la pérdida de precisión que puede producirse al usar el tipo de datos Double.It also illustrates the loss of precision that may occur when you use the Double data type. A un Double se le asigna un valor grande, que se asigna a un objeto BigInteger.A Double is assigned a large value, which is then assigned to a BigInteger object. Como se muestra en el resultado, esta asignación implica una pérdida de precisión.As the output shows, this assignment involves a loss of precision. Ambos valores se incrementan en uno.Both values are then incremented by one. El resultado muestra que el objeto BigInteger refleja el valor cambiado, mientras que el objeto Double no.The output shows that the BigInteger object reflects the changed value, whereas the Double object does not.

// Create a BigInteger from a large double value.
double doubleValue = -6e20;
BigInteger bigIntValue = new BigInteger(doubleValue);
Console.WriteLine("Original Double value: {0:N0}", doubleValue);
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue);
// Increment and then display both values.
doubleValue++;
bigIntValue += BigInteger.One;
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue);
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue);
// The example displays the following output:
//    Original Double value: -600,000,000,000,000,000,000
//    Original BigInteger value: -600,000,000,000,000,000,000
//    Incremented Double value: -600,000,000,000,000,000,000
//    Incremented BigInteger value: -599,999,999,999,999,999,999
' Create a BigInteger from a large double value.
Dim doubleValue As Double = -6e20
Dim bigIntValue As New BigInteger(doubleValue)
Console.WriteLine("Original Double value: {0:N0}", doubleValue)
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue)
' Increment and then display both values.
doubleValue += 1
bigIntValue += BigInteger.One
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue)
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue)
' The example displays the following output:
'    Original Double value: -600,000,000,000,000,000,000
'    Original BigInteger value: -600,000,000,000,000,000,000
'    Incremented Double value: -600,000,000,000,000,000,000
'    Incremented BigInteger value: -599,999,999,999,999,999,999

Comentarios

Cualquier parte fraccionaria del parámetro value se trunca al crear una instancia de un objeto BigInteger.Any fractional part of the value parameter is truncated when instantiating a BigInteger object.

Debido a la falta de precisión del tipo de datos Double, la llamada a este constructor puede provocar la pérdida de datos.Because of the lack of precision of the Double data type, calling this constructor can cause data loss.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de asignar explícitamente un valor de Double a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Double value to a BigInteger.

BigInteger(Int32)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 32 bits con signo.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

public:
 BigInteger(int value);
public BigInteger (int value);
new System.Numerics.BigInteger : int -> System.Numerics.BigInteger
Public Sub New (value As Integer)

Parámetros

value
Int32

Entero de 32 bits con signo.A 32-bit signed integer.

Ejemplos

En el ejemplo siguiente se llama al constructor BigInteger(Int32) para crear instancias de BigInteger valores de una matriz de enteros de 32 bits.The following example calls the BigInteger(Int32) constructor to instantiate BigInteger values from an array of 32-bit integers. También utiliza la conversión implícita para asignar cada valor entero de 32 bits a una variable BigInteger.It also uses implicit conversion to assign each 32-bit integer value to a BigInteger variable. A continuación, compara los dos valores para establecer que los valores BigInteger resultantes son los mismos.It then compares the two values to establish that the resulting BigInteger values are the same.

int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                   Int32.MaxValue };
BigInteger constructed, assigned;

foreach (int number in integers)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)); 
}                                                  
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True      
Dim integers() As Integer = { Int32.MinValue, -10534, -189, 0, 17, 113439,
                              Int32.MaxValue }
Dim constructed, assigned As BigInteger

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

Comentarios

No se produce ninguna pérdida de precisión al crear una instancia de un objeto BigInteger con este constructor.There is no loss of precision when instantiating a BigInteger object by using this constructor.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de la asignación de un valor de Int32 a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int32 value to a BigInteger.

La estructura de BigInteger no incluye constructores con un parámetro de tipo Byte, Int16, SByteo UInt16.The BigInteger structure does not include constructors with a parameter of type Byte, Int16, SByte, or UInt16. Sin embargo, el tipo de Int32 admite la conversión implícita de enteros de 8 y 16 bits con signo y sin signo en enteros de 32 bits con signo.However, the Int32 type supports the implicit conversion of 8-bit and 16-bit signed and unsigned integers to signed 32-bit integers. Como resultado, se llama a este constructor si value es cualquiera de estos cuatro tipos enteros.As a result, this constructor is called if value is any one of these four integral types.

BigInteger(Int64)

Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 64 bits con signo.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

public:
 BigInteger(long value);
public BigInteger (long value);
new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger
Public Sub New (value As Long)

Parámetros

value
Int64

Entero de 64 bits con signo.A 64-bit signed integer.

Ejemplos

En el ejemplo siguiente se llama al constructor BigInteger(Int64) para crear instancias de BigInteger valores de una matriz de enteros de 64 bits.The following example calls the BigInteger(Int64) constructor to instantiate BigInteger values from an array of 64-bit integers. También utiliza la conversión implícita para asignar cada valor entero de 64 bits a una variable BigInteger.It also uses implicit conversion to assign each 64-bit integer value to a BigInteger variable. A continuación, compara los dos valores para establecer que los valores BigInteger resultantes son los mismos.It then compares the two values to establish that the resulting BigInteger values are the same.

long[] longs = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                 Int64.MaxValue };
BigInteger constructed, assigned;

foreach (long number in longs)
{
   constructed = new BigInteger(number);
   assigned = number;
   Console.WriteLine("{0} = {1}: {2}", constructed, assigned, 
                     constructed.Equals(assigned)); 
}                                                  
// The example displays the following output:
//       -2147483648 = -2147483648: True
//       -10534 = -10534: True
//       -189 = -189: True
//       0 = 0: True
//       17 = 17: True
//       113439 = 113439: True
//       2147483647 = 2147483647: True      
Dim longs() As Long = { Int64.MinValue, -10534, -189, 0, 17, 113439,
                              Int64.MaxValue }
Dim constructed, assigned As BigInteger

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

Comentarios

No se produce ninguna pérdida de precisión al crear una instancia de un objeto BigInteger con este constructor.There is no loss of precision when instantiating a BigInteger object by using this constructor.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de la asignación de un valor de Int64 a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int64 value to a BigInteger.

BigInteger(Single)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión sencilla.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

public:
 BigInteger(float value);
public BigInteger (float value);
new System.Numerics.BigInteger : single -> System.Numerics.BigInteger
Public Sub New (value As Single)

Parámetros

value
Single

Un valor de punto flotante y precisión simple.A single-precision floating-point value.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra el uso del constructor BigInteger(Single) para crear una instancia de un objeto BigInteger.The following example illustrates the use of the BigInteger(Single) constructor to instantiate a BigInteger object. También se muestra la pérdida de precisión que puede producirse al usar el tipo de datos Single.It also illustrates the loss of precision that may occur when you use the Single data type. A un Single se le asigna un valor negativo grande, que se asigna a un objeto BigInteger.A Single is assigned a large negative value, which is then assigned to a BigInteger object. Como se muestra en el resultado, esta asignación implica una pérdida de precisión.As the output shows, this assignment involves a loss of precision. Ambos valores se incrementan en uno.Both values are then incremented by one. El resultado muestra que el objeto BigInteger refleja el valor cambiado, mientras que el objeto Single no.The output shows that the BigInteger object reflects the changed value, whereas the Single object does not.

// Create a BigInteger from a large negative Single value
float negativeSingle = Single.MinValue;
BigInteger negativeNumber = new BigInteger(negativeSingle);

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));

negativeSingle++;
negativeNumber++;

Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
// The example displays the following output:
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,440
//       -340,282,300,000,000,000,000,000,000,000,000,000,000
//       -340,282,346,638,528,859,811,704,183,484,516,925,439
' Create a BigInteger from a large negative Single value
Dim negativeSingle As Single = Single.MinValue
Dim negativeNumber As New BigInteger(negativeSingle)

Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))

negativeSingle += 1
negativeNumber += 1
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
' The example displays the following output:
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,440
'       -340,282,300,000,000,000,000,000,000,000,000,000,000
'       -340,282,346,638,528,859,811,704,183,484,516,925,439

Comentarios

Cualquier parte fraccionaria del parámetro value se trunca al crear una instancia de un objeto BigInteger.Any fractional part of the value parameter is truncated when instantiating a BigInteger object.

Debido a la falta de precisión del tipo de datos Single, la llamada a este constructor puede dar lugar a la pérdida de datos.Because of the lack of precision of the Single data type, calling this constructor can result in data loss.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de asignar explícitamente un valor de Single a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Single value to a BigInteger.

BigInteger(UInt32)

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS
System.Numerics.BigInteger.BigInteger(Int64)

Inicializa una nueva instancia de la estructura BigInteger utilizando un valor entero de 32 bits sin signo.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

public:
 BigInteger(System::UInt32 value);
[System.CLSCompliant(false)]
public BigInteger (uint value);
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger
Public Sub New (value As UInteger)

Parámetros

value
UInt32

Valor entero de 32 bits sin signo.An unsigned 32-bit integer value.

Atributos

Ejemplos

En el ejemplo siguiente se usa el constructor BigInteger(UInt32) y una instrucción de asignación para inicializar los valores BigInteger de una matriz de enteros de 32 bits sin signo.The following example uses the BigInteger(UInt32) constructor and an assignment statement to initialize BigInteger values from an array of unsigned 32-bit integers. A continuación, compara los dos valores para demostrar que los dos métodos de inicialización de un valor BigInteger producen resultados idénticos.It then compares the two values to demonstrate that the two methods of initializing a BigInteger value produce identical results.

uint[] unsignedValues = { 0, 16704, 199365, UInt32.MaxValue };
foreach (uint unsignedValue in unsignedValues)
{
   BigInteger constructedNumber = new BigInteger(unsignedValue);
   BigInteger assignedNumber = unsignedValue;
   if (constructedNumber.Equals(assignedNumber))
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber);
   else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber);
}
// The example displays the following output:
//    Both methods create a BigInteger whose value is 0.
//    Both methods create a BigInteger whose value is 16,704.
//    Both methods create a BigInteger whose value is 199,365.
//    Both methods create a BigInteger whose value is 4,294,967,295.
Dim unsignedValues() As UInteger = { 0, 16704, 199365, UInt32.MaxValue }
For Each unsignedValue As UInteger In unsignedValues
   Dim constructedNumber As New BigInteger(unsignedValue)
   Dim assignedNumber As BigInteger = unsignedValue
   If constructedNumber.Equals(assignedNumber) Then
      Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
                        constructedNumber)
   Else
      Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber)
   End If                         
Next
' The example displays the following output:
'    Both methods create a BigInteger whose value is 0.
'    Both methods create a BigInteger whose value is 16,704.
'    Both methods create a BigInteger whose value is 199,365.
'    Both methods create a BigInteger whose value is 4,294,967,295.

Comentarios

No se produce ninguna pérdida de precisión al crear una instancia de un BigInteger con este constructor.There is no loss of precision when instantiating a BigInteger using this constructor.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de la asignación de un valor de UInt32 a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt32 value to a BigInteger.

BigInteger(UInt64)

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS
System.Numerics.BigInteger.BigInteger(Double)

Inicializa una nueva instancia de la estructura BigInteger con un valor entero de 64 bits sin signo.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

public:
 BigInteger(System::UInt64 value);
[System.CLSCompliant(false)]
public BigInteger (ulong value);
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger
Public Sub New (value As ULong)

Parámetros

value
UInt64

Entero de 64 bits sin signo.An unsigned 64-bit integer.

Atributos

Ejemplos

En el ejemplo siguiente se usa el constructor BigInteger(UInt64) para crear una instancia de un objeto BigInteger cuyo valor es igual a MaxValue.The following example uses the BigInteger(UInt64) constructor to instantiate a BigInteger object whose value is equal to MaxValue.

ulong unsignedValue = UInt64.MaxValue;
BigInteger number = new BigInteger(unsignedValue);
Console.WriteLine(number.ToString("N0"));       
// The example displays the following output:
//       18,446,744,073,709,551,615      
Dim unsignedValue As ULong = UInt64.MaxValue
Dim number As New BigInteger(unsignedValue)
Console.WriteLine(number.ToString("N0"))       
' The example displays the following output:
'       18,446,744,073,709,551,615      

Comentarios

No se produce ninguna pérdida de precisión al crear una instancia de un BigInteger con este constructor.There is no loss of precision when instantiating a BigInteger using this constructor.

El valor de BigInteger que es el resultado de llamar a este constructor es idéntico al valor resultante de la asignación de un valor de UInt64 a una BigInteger.The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt64 value to a BigInteger.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inicializa una nueva instancia de la estructura BigInteger mediante los valores de un intervalo de solo lectura de bytes y, de forma opcional, indica la codificación de firma y el orden de bytes endianness.Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.

public BigInteger (ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);
new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigInteger
Public Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)

Parámetros

value
ReadOnlySpan<Byte>

Intervalo de solo lectura de bytes que representa el entero grande.A read-only span of bytes representing the big integer.

isUnsigned
Boolean

true para indicar que value usa codificación sin signo; de lo contrario, false (el valor predeterminado).true to indicate value uses unsigned encoding; otherwise, false (the default value).

isBigEndian
Boolean

true para indicar que value está en orden de bytes big endian; de lo contrario, false (el valor predeterminado).true to indicate value is in big-endian byte order; otherwise, false (the default value).

Se aplica a