BigInteger.Explicit Operador

Definición

Espacio de nombres:

System.Numerics

Ensamblados:

netstandard.dll, System.Runtime.Numerics.dll

Define una conversión explícita entre un objeto BigInteger y otro tipo.

Sobrecargas

Explicit(BigInteger to SByte)	Define una conversión explícita de un objeto BigInteger en un valor de 8 bits con signo. Esta API no es conforme a CLS. La alternativa conforme es Int16.
Explicit(Single to BigInteger)	Define una conversión explícita de un valor Single en un valor BigInteger.
Explicit(Complex to BigInteger)	Convierte explícitamente un Complex valor en un entero grande.
Explicit(BigInteger to UIntPtr)	Convierte explícitamente un entero grande en un UIntPtr valor.
Explicit(BigInteger to UInt64)	Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Double.
Explicit(BigInteger to UInt32)	Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Int64.
Explicit(BigInteger to UInt16)	Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Int32.
Explicit(BigInteger to UInt128)	Convierte explícitamente un entero grande en un UInt128 valor.
Explicit(BigInteger to Single)	Define una conversión explícita de un objeto BigInteger en un valor de punto flotante de precisión sencilla.
Explicit(BigInteger to IntPtr)	Convierte explícitamente un entero grande en un IntPtr valor.
Explicit(BigInteger to Int64)	Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits con signo.
Explicit(BigInteger to Int16)	Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits con signo.
Explicit(BigInteger to Int128)	Convierte explícitamente un entero grande en un Int128 valor.
Explicit(BigInteger to Half)	Convierte explícitamente un entero grande en un Half valor.
Explicit(BigInteger to Double)	Define una conversión explícita de un objeto BigInteger en un valor Double.
Explicit(BigInteger to Decimal)	Define una conversión explícita de un objeto BigInteger en un valor Decimal.
Explicit(BigInteger to Char)	Convierte explícitamente un entero grande en un Char valor.
Explicit(BigInteger to Byte)	Define una conversión explícita de un objeto BigInteger en un valor de byte sin signo.
Explicit(Half to BigInteger)	Convierte explícitamente un Half valor en un entero grande.
Explicit(Double to BigInteger)	Define una conversión explícita de un valor Double en un valor BigInteger.
Explicit(Decimal to BigInteger)	Define una conversión explícita de un objeto Decimal en un valor BigInteger.
Explicit(BigInteger to Int32)	Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits con signo.

Explicit(BigInteger to SByte)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Int16

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

Esta API no es conforme a CLS. La alternativa conforme es Int16.

C#

[System.CLSCompliant(false)]
public static explicit operator sbyte(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un valor de 8 bits con signo.

Devoluciones

SByte

Objeto que contiene el valor del parámetro value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que SByte.MinValue o es mayor que SByte.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a SByte valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de SByte datos.

C#

// BigInteger to SByte conversion.
BigInteger goodSByte = BigInteger.MinusOne;
BigInteger badSByte = -130;

sbyte sByteFromBigInteger;

// Successful conversion using cast operator.
sByteFromBigInteger = (sbyte) goodSByte;
Console.WriteLine(sByteFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   sByteFromBigInteger = (sbyte) badSByte;
   Console.WriteLine(sByteFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badSByte, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CSByte en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de SByte datos. No hay ninguna pérdida de precisión en el valor resultante SByte si la conversión es correcta.

Explicit(Single to BigInteger)

Source:

BigInteger.cs

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

C#

public static explicit operator System.Numerics.BigInteger(float value);

Parámetros

value

Single

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es NaN, PositiveInfinity o NegativeInfinity.

Ejemplos

En el ejemplo siguiente se convierten los elementos individuales de una matriz de Single valores BigInteger en objetos y, a continuación, se muestra el resultado de cada conversión. Tenga en cuenta que cualquier parte fraccionarcional de un Single valor se trunca durante la conversión.

C#

float[] singles = { Single.MinValue, -1.430955172e03f, 2.410970032e05f,
                    Single.MaxValue, Single.PositiveInfinity,
                     Single.NegativeInfinity, Single.NaN };
BigInteger number;

Console.WriteLine("{0,37} {1,37}\n", "Single", "BigInteger");

foreach (float value in singles)
{
   try {
      number = (BigInteger) value;
      Console.WriteLine("{0,37} {1,37}", value, number);
   }
   catch (OverflowException) {
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException");
   }
}
// The example displays the following output:
//           Single                            BigInteger
//
//    -3.402823E+38   -3.4028234663852885981170418348E+38
//        -1430.955                                 -1430
//           241097                                241097
//     3.402823E+38    3.4028234663852885981170418348E+38
//         Infinity                     OverflowException
//        -Infinity                     OverflowException
//              NaN                     OverflowException

Comentarios

Cualquier parte fraccionarcional del parámetro se trunca antes de la value conversión.

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Dado que la conversión de Single a BigInteger puede implicar truncar cualquier parte fraccionaria de value, los compiladores de lenguaje no realizan esta conversión automáticamente. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType en Visual Basic). De lo contrario, muestran un error del compilador.

En el caso de los lenguajes que no admiten operadores personalizados, el método alternativo es BigInteger.BigInteger(Single).

Explicit(Complex to BigInteger)

Source:

BigInteger.cs

Convierte explícitamente un Complex valor en un entero grande.

C#

public static explicit operator System.Numerics.BigInteger(System.Numerics.Complex value);

Parámetros

value

Complex

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Explicit(BigInteger to UIntPtr)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Convierte explícitamente un entero grande en un UIntPtr valor.

C#

[System.CLSCompliant(false)]
public static explicit operator UIntPtr(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

UIntPtr

value convertido en UIntPtr valor.

Atributos

CLSCompliantAttribute

Explicit(BigInteger to UInt64)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Double

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

Esta API no es conforme a CLS. La alternativa conforme es Double.

C#

[System.CLSCompliant(false)]
public static explicit operator ulong(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 64 bits sin signo.

Devoluciones

UInt64

Objeto que contiene el valor del parámetro value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que UInt64.MinValue o es mayor que UInt64.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a UInt64 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de UInt64 datos.

C#

// BigInteger to UInt64 conversion.
BigInteger goodULong = 2000000000;
BigInteger badULong = BigInteger.Pow(goodULong, 3);

ulong uLongFromBigInteger;

// Successful conversion using cast operator.
uLongFromBigInteger = (ulong) goodULong;
Console.WriteLine(uLongFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uLongFromBigInteger = (ulong) badULong;
   Console.WriteLine(uLongFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badULong, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CULng en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de UInt64 datos. No hay ninguna pérdida de precisión en el valor resultante UInt64 si la conversión es correcta.

Explicit(BigInteger to UInt32)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Int64

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

Esta API no es conforme a CLS. La alternativa conforme es Int64.

C#

[System.CLSCompliant(false)]
public static explicit operator uint(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 32 bits sin signo.

Devoluciones

UInt32

Objeto que contiene el valor del parámetro value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que UInt32.MinValue o es mayor que UInt32.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a UInt32 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de UInt32 datos.

C#

// BigInteger to UInt32 conversion.
BigInteger goodUInteger = 200000;
BigInteger badUInteger = 65000000000;

uint uIntegerFromBigInteger;

// Successful conversion using cast operator.
uIntegerFromBigInteger = (uint) goodInteger;
Console.WriteLine(uIntegerFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uIntegerFromBigInteger = (uint) badUInteger;
   Console.WriteLine(uIntegerFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badUInteger, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CUInt en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de UInt32 datos. No hay ninguna pérdida de precisión en el valor resultante UInt32 si la conversión es correcta.

Explicit(BigInteger to UInt16)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS

System.Int32

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

Esta API no es conforme a CLS. La alternativa conforme es Int32.

C#

[System.CLSCompliant(false)]
public static explicit operator ushort(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 16 bits sin signo.

Devoluciones

UInt16

Objeto que contiene el valor del parámetro value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que UInt16.MinValue o es mayor que UInt16.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a UInt16 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de UInt16 datos.

C#

// BigInteger to UInt16 conversion.
BigInteger goodUShort = 20000;
BigInteger badUShort = 66000;

ushort uShortFromBigInteger;

// Successful conversion using cast operator.
uShortFromBigInteger = (ushort) goodUShort;
Console.WriteLine(uShortFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uShortFromBigInteger = (ushort) badUShort;
   Console.WriteLine(uShortFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badUShort, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CUShort en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de UInt16 datos. No hay ninguna pérdida de precisión en el valor resultante UInt16 si la conversión es correcta.

Explicit(BigInteger to UInt128)

Source:

BigInteger.cs

Importante

Esta API no es conforme a CLS.

Convierte explícitamente un entero grande en un UInt128 valor.

C#

[System.CLSCompliant(false)]
public static explicit operator UInt128(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

UInt128

value convertido en UInt128 valor.

Atributos

CLSCompliantAttribute

Explicit(BigInteger to Single)

Source:

BigInteger.cs

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

C#

public static explicit operator float(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un valor de punto flotante de precisión sencilla.

Devoluciones

Single

Objeto que contiene la representación más cercana del parámetro value.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Single valores.

C#

// BigInteger to Single conversion.
BigInteger goodSingle = (BigInteger) 102.43e22F;
BigInteger badSingle = (BigInteger) float.MaxValue;
badSingle = badSingle * 2;

float singleFromBigInteger;

// Successful conversion using cast operator.
singleFromBigInteger = (float) goodSingle;
Console.WriteLine(singleFromBigInteger);

// Convert an out-of-bounds BigInteger value to a Single.
singleFromBigInteger = (float) badSingle;
Console.WriteLine(singleFromBigInteger);

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar pérdida de datos o una pérdida de precisión. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CSng en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que el BigInteger valor puede estar fuera del intervalo del tipo de Single datos, esta operación es una conversión de restricción. Si la conversión no se realiza correctamente, no inicia una OverflowExceptionexcepción . En su lugar, si el BigInteger valor es menor que Single.MinValue, el valor resultante Single es Single.NegativeInfinity. Si el BigInteger valor es mayor que Single.MaxValue, el valor resultante Single es Single.PositiveInfinity.

La conversión de un BigInteger objeto a Single puede implicar una pérdida de precisión. En algunos casos, la pérdida de precisión puede hacer que la operación de conversión o conversión se realice correctamente incluso si el BigInteger valor está fuera del intervalo del tipo de Single datos. Esto se muestra en el ejemplo siguiente. Asigna el valor máximo de a Single dos BigInteger variables, incrementa una BigInteger variable en 9,999e291 y prueba las dos variables para la igualdad. Según lo previsto, la llamada al BigInteger.Equals(BigInteger) método muestra que son diferentes. Sin embargo, la conversión del valor mayor a un Single valor se realiza correctamente, aunque el BigInteger valor ahora supera Single.MaxValue.BigInteger

C#

// Increase a BigInteger so it exceeds Single.MaxValue.
BigInteger number1 = (BigInteger) Single.MaxValue;
BigInteger number2 = number1;
number2 = number2 + (BigInteger) 9.999e30;
// Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1));

// Convert the BigInteger to a Single.
float sng = (float) number2;

// Display the two values.
Console.WriteLine("BigInteger: {0}", number2);
Console.WriteLine("Single:     {0}", sng);
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 3.4028235663752885981170396038E+38
//       Single:     3.402823E+38

Explicit(BigInteger to IntPtr)

Source:

BigInteger.cs

Convierte explícitamente un entero grande en un IntPtr valor.

C#

public static explicit operator IntPtr(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

IntPtr

value convertido en IntPtr valor.

Explicit(BigInteger to Int64)

Source:

BigInteger.cs

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

C#

public static explicit operator long(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 64 bits con signo.

Devoluciones

Int64

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es menor que Int64.MinValue o es mayor que Int64.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Int64 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de Int64 datos.

C#

// BigInteger to Int64 conversion.
BigInteger goodLong = 2000000000;
BigInteger badLong = BigInteger.Pow(goodLong, 3);

long longFromBigInteger;

// Successful conversion using cast operator.
longFromBigInteger = (long) goodLong;
Console.WriteLine(longFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   longFromBigInteger = (long) badLong;
   Console.WriteLine(longFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badLong, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CLng en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de Int64 datos.

Explicit(BigInteger to Int16)

Source:

BigInteger.cs

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

C#

public static explicit operator short(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 16 bits con signo.

Devoluciones

Int16

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es menor que Int16.MinValue o es mayor que Int16.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Int16 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de Int16 datos.

C#

// BigInteger to Int16 conversion.
BigInteger goodShort = 20000;
BigInteger badShort = 33000;

short shortFromBigInteger;

// Successful conversion using cast operator.
shortFromBigInteger = (short) goodShort;
Console.WriteLine(shortFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   shortFromBigInteger = (short) badShort;
   Console.WriteLine(shortFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badShort, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CShort en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de Int16 datos. No hay ninguna pérdida de precisión en el valor resultante Int16 si la conversión es correcta.

Explicit(BigInteger to Int128)

Source:

BigInteger.cs

Convierte explícitamente un entero grande en un Int128 valor.

C#

public static explicit operator Int128(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

Int128

value convertido en Int128 valor.

Explicit(BigInteger to Half)

Source:

BigInteger.cs

Convierte explícitamente un entero grande en un Half valor.

C#

public static explicit operator Half(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

Half

value convertido en Half valor.

Explicit(BigInteger to Double)

Source:

BigInteger.cs

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

C#

public static explicit operator double(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un tipo Double.

Devoluciones

Double

Objeto que contiene el valor del parámetro value.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Double valores.

C#

// BigInteger to Double conversion.
BigInteger goodDouble = (BigInteger) 102.43e22;
BigInteger badDouble = (BigInteger) Double.MaxValue;
badDouble = badDouble * 2;

double doubleFromBigInteger;

// successful conversion using cast operator.
doubleFromBigInteger = (double) goodDouble;
Console.WriteLine(doubleFromBigInteger);

// Convert an out-of-bounds BigInteger value to a Double.
doubleFromBigInteger = (double) badDouble;
Console.WriteLine(doubleFromBigInteger);

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CDbl en Visual Basic).

Dado que el BigInteger valor puede estar fuera del intervalo del tipo de Double datos, esta operación es una conversión de restricción. Si la conversión no se realiza correctamente, no inicia una OverflowExceptionexcepción . En su lugar, si el BigInteger valor es menor que Double.MinValue, el valor resultante Double es Double.NegativeInfinity. Si el BigInteger valor es mayor que Double.MaxValue, el valor resultante Double es Double.PositiveInfinity.

La conversión de un BigInteger objeto a Double puede implicar una pérdida de precisión. En algunos casos, la pérdida de precisión puede hacer que la operación de conversión o conversión se realice correctamente incluso si el BigInteger valor está fuera del intervalo del tipo de Double datos. Esto se muestra en el ejemplo siguiente. Asigna el valor máximo de a Double dos BigInteger variables, incrementa una BigInteger variable en 9,999e291 y prueba las dos variables para la igualdad. Según lo previsto, la llamada al BigInteger.Equals(BigInteger) método muestra que son diferentes. Sin embargo, la conversión del valor mayor a un Double valor se realiza correctamente, aunque el BigInteger valor ahora supera Double.MaxValue.BigInteger

C#

// Increase a BigInteger so it exceeds Double.MaxValue.
BigInteger number1 = (BigInteger) Double.MaxValue;
BigInteger number2 = number1;
number2 = number2 + (BigInteger) 9.999e291;
// Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1));

// Convert the BigInteger to a Double.
double dbl = (double) number2;

// Display the two values.
Console.WriteLine("BigInteger: {0}", number2);
Console.WriteLine("Double:     {0}", dbl);
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 1.7976931348623158081352742373E+308
//       Double:     1.79769313486232E+308

Explicit(BigInteger to Decimal)

Source:

BigInteger.cs

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

C#

public static explicit operator decimal(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un tipo Decimal.

Devoluciones

Decimal

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es menor que Decimal.MinValue o mayor que Decimal.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Decimal valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de Decimal datos.

C#

// BigInteger to Decimal conversion.
BigInteger goodDecimal = 761652543;
BigInteger badDecimal = (BigInteger) Decimal.MaxValue;
badDecimal += BigInteger.One;

Decimal decimalFromBigInteger;

// Successful conversion using cast operator.
decimalFromBigInteger = (decimal) goodDecimal;
Console.WriteLine(decimalFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   decimalFromBigInteger = (decimal) badDecimal;
   Console.WriteLine(decimalFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badDecimal, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CDec en Visual Basic).

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de Decimal datos.

Explicit(BigInteger to Char)

Source:

BigInteger.cs

Convierte explícitamente un entero grande en un Char valor.

C#

public static explicit operator char(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir.

Devoluciones

Char

value convertido en Char valor.

Explicit(BigInteger to Byte)

Source:

BigInteger.cs

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

C#

public static explicit operator byte(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un tipo Byte.

Devoluciones

Byte

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es menor que Byte.MinValue o mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Byte valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de Byte datos.

C#

// BigInteger to Byte conversion.
BigInteger goodByte = BigInteger.One;
BigInteger badByte = 256;

byte byteFromBigInteger;

// Successful conversion using cast operator.
byteFromBigInteger = (byte) goodByte;
Console.WriteLine(byteFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   byteFromBigInteger = (byte) badByte;
   Console.WriteLine(byteFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badByte, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CByte en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de Byte datos. No hay ninguna pérdida de precisión en el valor resultante Byte si la conversión es correcta.

Explicit(Half to BigInteger)

Source:

BigInteger.cs

Convierte explícitamente un Half valor en un entero grande.

C#

public static explicit operator System.Numerics.BigInteger(Half value);

Parámetros

value

Half

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Explicit(Double to BigInteger)

Source:

BigInteger.cs

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

C#

public static explicit operator System.Numerics.BigInteger(double value);

Parámetros

value

Double

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es NaN, PositiveInfinity o NegativeInfinity.

Ejemplos

En el ejemplo siguiente se convierten los elementos individuales de una matriz de Double valores BigInteger en objetos y, a continuación, se muestra el resultado de cada conversión. Tenga en cuenta que cualquier parte fraccionarcional de un Double valor se trunca durante la conversión.

C#

double[] doubles = { Double.MinValue, -1.430955172e03, 2.410970032e05,
                     Double.MaxValue, Double.PositiveInfinity,
                     Double.NegativeInfinity, Double.NaN };
BigInteger number;

Console.WriteLine("{0,37} {1,37}\n", "Double", "BigInteger");

foreach (double value in doubles)
{
   try {
      number = (BigInteger) value;
      Console.WriteLine("{0,37} {1,37}", value, number);
   }
   catch (OverflowException) {
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException");
   }
}
// The example displays the following output:
//                                Double                            BigInteger
//
//                -1.79769313486232E+308  -1.7976931348623157081452742373E+308
//                          -1430.955172                                 -1430
//                           241097.0032                                241097
//                 1.79769313486232E+308   1.7976931348623157081452742373E+308
//                              Infinity                     OverflowException
//                             -Infinity                     OverflowException
//                                   NaN                     OverflowException

Comentarios

Cualquier parte fraccionarcional del parámetro se trunca antes de la value conversión.

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Dado que la conversión de Double a BigInteger puede implicar truncar cualquier parte fraccionaria de value, los compiladores de lenguaje no realizan esta conversión automáticamente. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType en Visual Basic). De lo contrario, muestran un error del compilador.

En el caso de los lenguajes que no admiten operadores personalizados, el método alternativo es BigInteger.BigInteger(Double).

Explicit(Decimal to BigInteger)

Source:

BigInteger.cs

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

C#

public static explicit operator System.Numerics.BigInteger(decimal value);

Parámetros

value

Decimal

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Ejemplos

En el ejemplo siguiente se convierten los elementos individuales de una matriz de Decimal valores BigInteger en objetos y, a continuación, se muestra el resultado de cada conversión. Tenga en cuenta que cualquier parte fraccionarcional de un Decimal valor se trunca durante la conversión.

C#

decimal[] decimals = { Decimal.MinValue, -15632.991m, 9029321.12m,
                       Decimal.MaxValue };
BigInteger number;

Console.WriteLine("{0,35} {1,35}\n", "Decimal", "BigInteger");

foreach (decimal value in decimals)
{
   number = (BigInteger) value;
   Console.WriteLine("{0,35} {1,35}", value, number);
}
// The example displays the following output:
//
//                          Decimal                          BigInteger
//
//    -79228162514264337593543950335      -79228162514264337593543950335
//                       -15632.991                              -15632
//                       9029321.12                             9029321
//    79228162514264337593543950335       79228162514264337593543950335

Comentarios

Cualquier parte fraccionarcional del parámetro se trunca antes de la value conversión.

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Dado que la conversión de Decimal a BigInteger puede implicar truncar cualquier parte fraccionaria de value, los compiladores de lenguaje no realizan esta conversión automáticamente. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType en Visual Basic). De lo contrario, muestran un error del compilador.

En el caso de los lenguajes que no admiten operadores personalizados, el método alternativo es BigInteger.BigInteger(Decimal).

Explicit(BigInteger to Int32)

Source:

BigInteger.cs

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

C#

public static explicit operator int(System.Numerics.BigInteger value);

Parámetros

value

BigInteger

Valor que se va a convertir en un entero de 32 bits con signo.

Devoluciones

Int32

Objeto que contiene el valor del parámetro value.

Excepciones

OverflowException

value es menor que Int32.MinValue o es mayor que Int32.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra la conversión de BigInteger a Int32 valores. También controla un OverflowException valor que se produce porque el BigInteger valor está fuera del intervalo del tipo de Int32 datos.

C#

// BigInteger to Int32 conversion.
BigInteger goodInteger = 200000;
BigInteger badInteger = 65000000000;

int integerFromBigInteger;

// Successful conversion using cast operator.
integerFromBigInteger = (int) goodInteger;
Console.WriteLine(integerFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   integerFromBigInteger = (int) badInteger;
   Console.WriteLine(integerFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badInteger, e.Message);
}
Console.WriteLine();

Comentarios

Las sobrecargas del Explicit(Decimal to BigInteger) método definen los tipos a los que se puede convertir o desde los que se puede convertir un BigInteger objeto. Los compiladores de lenguaje no realizan esta conversión automáticamente porque pueden implicar la pérdida de datos. En su lugar, realizan la conversión solo si se usa un operador de conversión (en C#) o una función de conversión (como CType o CInt en Visual Basic). De lo contrario, muestran un error del compilador.

Dado que esta operación define una conversión de restricción, puede producir una OverflowException en tiempo de ejecución si el BigInteger valor está fuera del intervalo del tipo de Int32 datos. No hay ninguna pérdida de precisión en el valor resultante Int32 si la conversión es correcta.