BigInteger.Explicit Operador

Referencia

Definición

Espacio de nombres:: System.Numerics

Ensamblado:: System.Runtime.Numerics.dll

Ensamblado:: System.Numerics.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

Source:: BigInteger.cs

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.

public:
 static explicit operator System::SByte(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> sbyte

Public Shared Narrowing Operator CType (value As BigInteger) As SByte

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.

// 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();

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

// Successful conversion using cast operator.
let sByteFromBigInteger = sbyte goodSByte
printfn $"{sByteFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let sByteFromBigInteger = sbyte badSByte
    printfn $"{sByteFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badSByte}:\n   {e.Message}"

' BigInteger to SByte conversion.
Dim goodSByte As BigInteger = BigInteger.MinusOne
Dim badSByte As BigInteger = -130

Dim sByteFromBigInteger As SByte

' Convert using CType function.
sByteFromBigInteger = CType(goodSByte, SByte)
Console.WriteLine(sByteFromBigInteger)
' Convert using CSByte function.
sByteFromBigInteger = CSByte(goodSByte)
Console.WriteLine(sByteFromBigInteger)

' Handle conversion that should result in overflow.
Try
   sByteFromBigInteger = CType(badSByte, SByte)
   Console.WriteLine(sByteFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badSByte, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(Single to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : single -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Single) As BigInteger

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.

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

let singles =
    [| Single.MinValue
       -1.430955172e03f
       2.410970032e05f
       Single.MaxValue
       Single.PositiveInfinity
       Single.NegativeInfinity
       Single.NaN |]

printfn "%37s %37s\n" "Single" "BigInteger"

for value in singles do
    try
        let number = BigInteger(value)
        printfn "%37O %37O" value number
    with :? OverflowException ->
        printfn "%37O %37s" 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

Dim singles() As Single = { Single.MinValue, -1.430955172e03, 2.410970032e05, 
                            Single.MaxValue, Single.PositiveInfinity, 
                            Single.NegativeInfinity, Single.NaN }
Dim number As BigInteger

Console.WriteLine("{0,37} {1,37}", "Single", "BigInteger")
Console.WriteLine()
For Each value As Single In singles
   Try
      number = CType(value, BigInteger)
      Console.WriteLine("{0,37} {1,37}", value, number)
   Catch e As OverflowException
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException")
   End Try
Next     
' 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).

Se aplica a

Explicit(Complex to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.Complex -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Complex) As BigInteger

Parámetros

value: Complex

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Se aplica a

Explicit(BigInteger to UIntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

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

public:
 static explicit operator UIntPtr(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> unativeint

Public Shared Narrowing Operator CType (value As BigInteger) As UIntPtr

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

UIntPtr

unativeint

value convertido en UIntPtr valor.

Atributos: CLSCompliantAttribute

Se aplica a

Explicit(BigInteger to UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

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.

public:
 static explicit operator System::UInt64(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint64

Public Shared Narrowing Operator CType (value As BigInteger) As ULong

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.

// 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();

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

// Successful conversion using cast operator.
let uLongFromBigInteger = uint64 goodULong
printfn $"{uLongFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uLongFromBigInteger = uint64 badULong
    printfn $"{uLongFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badULong}:\n   {e.Message}"

' BigInteger to UInt64 conversion.
Dim goodULong As BigInteger = 2000000000
Dim badULong As BigInteger = BigInteger.Pow(goodULong, 3)

Dim uLongFromBigInteger As ULong

' Convert using CType function.
uLongFromBigInteger = CType(goodULong, ULong)
Console.WriteLine(uLongFromBigInteger)
' Convert using CULng function.
uLongFromBigInteger = CULng(goodULong)
Console.WriteLine(uLongFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uLongFromBigInteger = CType(badULong, ULong)
   Console.WriteLine(uLongFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badULong, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(BigInteger to UInt32)

Source:: BigInteger.cs

Source:: BigInteger.cs

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.

public:
 static explicit operator System::UInt32(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint32

Public Shared Narrowing Operator CType (value As BigInteger) As UInteger

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.

// 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();

// BigInteger to UInt32 conversion.
let goodUInteger = bigint 200000
let badUInteger = bigint 65000000000L

// Successful conversion using cast operator.
let uIntegerFromBigInteger = uint goodInteger
printfn $"{uIntegerFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uIntegerFromBigInteger = uint badUInteger
    printfn $"{uIntegerFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badUInteger}:\n   {e.Message}"

' BigInteger to UInt32 conversion.
Dim goodUInteger As BigInteger = 200000
Dim badUInteger As BigInteger = 65000000000

Dim uIntegerFromBigInteger As UInteger

' Convert using CType function.
uIntegerFromBigInteger = CType(goodInteger, UInteger)
Console.WriteLine(uIntegerFromBigInteger)
' Convert using CUInt function.
uIntegerFromBigInteger = CUInt(goodInteger)
Console.WriteLine(uIntegerFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uIntegerFromBigInteger = CType(badUInteger, UInteger)
   Console.WriteLine(uIntegerFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badUInteger, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(BigInteger to UInt16)

Source:: BigInteger.cs

Source:: BigInteger.cs

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.

public:
 static explicit operator System::UInt16(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint16

Public Shared Narrowing Operator CType (value As BigInteger) As UShort

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.

// 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();

// BigInteger to UInt16 conversion.
let goodUShort = bigint 20000
let badUShort = bigint 66000

// Successful conversion using cast operator.
let uShortFromBigInteger = uint16 goodUShort
printfn $"{uShortFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uShortFromBigInteger = uint16 badUShort
    printfn $"{uShortFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badSByte}:\n   {e.Message}"

' BigInteger to UInt16 conversion.
Dim goodUShort As BigInteger = 20000
Dim badUShort As BigInteger = 66000

Dim uShortFromBigInteger As UShort

' Convert using CType function.
uShortFromBigInteger = CType(goodUShort, UShort)
Console.WriteLine(uShortFromBigInteger)
' Convert using CUShort function.
uShortFromBigInteger = CUShort(goodUShort)
Console.WriteLine(uShortFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uShortFromBigInteger = CType(badUShort, UShort)
   Console.WriteLine(uShortFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badUShort, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(BigInteger to UInt128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

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

public:
 static explicit operator UInt128(System::Numerics::BigInteger value);

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

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> UInt128

Public Shared Narrowing Operator CType (value As BigInteger) As UInt128

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

UInt128

value convertido en UInt128 valor.

Atributos: CLSCompliantAttribute

Se aplica a

Explicit(BigInteger to Single)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> single

Public Shared Narrowing Operator CType (value As BigInteger) As Single

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.

// 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);

// BigInteger to Single conversion.
let goodSingle = bigint 102.43e22F
let badSingle = bigint Single.MaxValue * bigint 2

// Successful conversion using cast operator.
let singleFromBigInteger = float32 goodSingle
printfn $"{singleFromBigInteger}"

// Convert an out-of-bounds BigInteger value to a Single.
let singleFromBigInteger = float32 badSingle
printfn $"{singleFromBigInteger}"

' BigInteger to Single conversion.
Dim goodSingle As BigInteger = 102.43e22
Dim badSingle As BigInteger = CType(Single.MaxValue, BigInteger)  
badSingle = badSingle * 2

Dim singleFromBigInteger As Single

' Convert using CType function.
singleFromBigInteger = CType(goodSingle, Single)
Console.WriteLine(singleFromBigInteger)
' Convert using CSng function.
singleFromBigInteger = CSng(goodSingle)
Console.WriteLine(singleFromBigInteger)

' Convert an out-of-bounds BigInteger value to a Single.
singleFromBigInteger = CType(badSingle, Single)
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

// 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

// Increase a BigInteger so it exceeds Single.MaxValue.
let number1 = bigint Single.MaxValue

let number2 = number1 + bigint 9.999e30
// Compare the BigInteger values for equality.
printfn $"BigIntegers equal: {number2.Equals number1}"

// Convert the BigInteger to a Single.
let sng = float32 number2

// Display the two values.
printfn $"BigInteger: {number2}"
printfn $"Single:     {sng}"
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 3.4028235663752885981170396038E+38
//       Single:     3.402823E+38

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

' Convert the BigInteger to a Single.
Dim sng As Single = CType(number2, Single)

' 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

Se aplica a

Explicit(BigInteger to IntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> nativeint

Public Shared Narrowing Operator CType (value As BigInteger) As IntPtr

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

IntPtr

nativeint

value convertido en IntPtr valor.

Se aplica a

Explicit(BigInteger to Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> int64

Public Shared Narrowing Operator CType (value As BigInteger) As Long

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.

// 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();

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

// Successful conversion using cast operator.
let longFromBigInteger = int64 goodLong
printfn $"{longFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let longFromBigInteger = int64 badLong
    printfn $"{longFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badLong}:\n   {e.Message}"

' BigInteger to Int64 conversion.
Dim goodLong As BigInteger = 2000000000
Dim badLong As BigInteger = BigInteger.Pow(goodLong, 3)

Dim longFromBigInteger As Long

' Convert using CType function.
longFromBigInteger = CType(goodLong, Long)
Console.WriteLine(longFromBigInteger)
' Convert using CLng function.
longFromBigInteger = CLng(goodLong)
Console.WriteLine(longFromBigInteger)

' Handle conversion that should result in overflow.
Try
   longFromBigInteger = CType(badLong, Long)
   Console.WriteLine(longFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badLong, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(BigInteger to Int16)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> int16

Public Shared Narrowing Operator CType (value As BigInteger) As Short

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.

// 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();

// BigInteger to Int16 conversion.
let goodShort = bigint 20000
let badShort = bigint 33000

// Successful conversion using cast operator.
let shortFromBigInteger = int16 goodShort
printfn $"{shortFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let shortFromBigInteger = int16 badShort
    printfn $"{shortFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badShort}:\n   {e.Message}"

' BigInteger to Int16 conversion.
Dim goodShort As BigInteger = 20000
Dim badShort As BigInteger = 33000

Dim shortFromBigInteger As Short

' Convert using CType function.
shortFromBigInteger = CType(goodShort, Short)
Console.WriteLine(shortFromBigInteger)
' Convert using CShort function.
shortFromBigInteger = CShort(goodShort)
Console.WriteLine(shortFromBigInteger)

' Handle conversion that should result in overflow.
Try
   shortFromBigInteger = CType(badShort, Short)
   Console.WriteLine(shortFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badShort, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(BigInteger to Int128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> Int128

Public Shared Narrowing Operator CType (value As BigInteger) As Int128

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

Int128

value convertido en Int128 valor.

Se aplica a

Explicit(BigInteger to Half)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> Half

Public Shared Narrowing Operator CType (value As BigInteger) As Half

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

Half

value convertido en Half valor.

Se aplica a

Explicit(BigInteger to Double)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> double

Public Shared Narrowing Operator CType (value As BigInteger) As Double

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.

// 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);

// BigInteger to Double conversion.
let goodDouble = bigint 102.43e22
let badDouble = bigint Double.MaxValue * bigint 2

// successful conversion using cast operator.
let doubleFromBigInteger = double goodDouble
printfn $"{doubleFromBigInteger}"

// Convert an out-of-bounds BigInteger value to a Double.
let doubleFromBigInteger = double badDouble
printfn $"{doubleFromBigInteger}"

' BigInteger to Double conversion.
Dim goodDouble As BigInteger = 102.43e22
Dim badDouble As BigInteger = CType(Double.MaxValue, BigInteger)  
badDouble = badDouble * 2

Dim doubleFromBigInteger As Double

' Convert using CType function.
doubleFromBigInteger = CType(goodDouble, Double)
Console.WriteLine(doubleFromBigInteger)
' Convert using CDbl function.
doubleFromBigInteger = CDbl(goodDouble)
Console.WriteLine(doubleFromBigInteger)

' Convert an out-of-bounds BigInteger value to a Double.
doubleFromBigInteger = CType(badDouble, Double)
Console.WriteLine(doubleFromBigInteger)

Comentarios

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

// 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

// Increase a BigInteger so it exceeds Double.MaxValue.
let number1 = bigint Double.MaxValue
let number2 = number1 + bigint 9.999e291
// Compare the BigInteger values for equality.
printfn $"BigIntegers equal: {number2.Equals number1}"

// Convert the BigInteger to a Double.
let dbl = float number2

// Display the two values.
printfn $"BigInteger: {number2}"
printfn $"Double:     {dbl}"
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 1.7976931348623158081352742373E+308
//       Double:     1.79769313486232E+308

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

' Convert the BigInteger to a Double.
Dim dbl As Double = CType(number2, Double)

' 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

Se aplica a

Explicit(BigInteger to Decimal)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 static explicit operator System::Decimal(System::Numerics::BigInteger value);

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

static member op_Explicit : System.Numerics.BigInteger -> decimal

Public Shared Narrowing Operator CType (value As BigInteger) As Decimal

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.

// 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();

// BigInteger to Decimal conversion.
let goodDecimal = 761652543
let badDecimal = bigint Decimal.MaxValue + BigInteger.One

// Successful conversion using cast operator.
let decimalFromBigInteger = decimal goodDecimal
printfn $"{decimalFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let decimalFromBigInteger = decimal badDecimal
    printfn $"{decimalFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badDecimal}:\n   {e.Message}"

' BigInteger to Decimal conversion.
Dim goodDecimal As BigInteger = 761652543
Dim badDecimal As BigInteger = CType(Decimal.MaxValue, BigInteger) 
badDecimal += BigInteger.One

Dim decimalFromBigInteger As Decimal

' Convert using CType function.
decimalFromBigInteger = CType(goodDecimal, Decimal)
Console.WriteLine(decimalFromBigInteger)
' Convert using CDec function.
decimalFromBigInteger = CDec(goodDecimal)
Console.WriteLine(decimalFromBigInteger)

' Handle conversion that should result in overflow.
Try
   decimalFromBigInteger = CType(badDecimal, Decimal)
   Console.WriteLine(decimalFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badDecimal, vbCrLf, e.Message)
End Try
Console.WriteLine()

Comentarios

Se aplica a

Explicit(BigInteger to Char)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> char

Public Shared Narrowing Operator CType (value As BigInteger) As Char

Parámetros

value: BigInteger

Valor que se va a convertir.

Devoluciones

Char

value convertido en Char valor.

Se aplica a

Explicit(BigInteger to Byte)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 static explicit operator System::Byte(System::Numerics::BigInteger value);

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

static member op_Explicit : System.Numerics.BigInteger -> byte

Public Shared Narrowing Operator CType (value As BigInteger) As Byte

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.

// 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();

// BigInteger to Byte conversion.
let goodByte = BigInteger.One
let badByte = bigint 256

// Successful conversion using cast operator.
let byteFromBigInteger = byte goodByte
printfn $"{byteFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let byteFromBigInteger = byte badByte
    printfn $"{byteFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badByte}:\n   {e.Message}"

' BigInteger to Byte conversion.
Dim goodByte As BigInteger = BigInteger.One
Dim badByte As BigInteger = 256

Dim byteFromBigInteger As Byte   

' Convert using CType function.
byteFromBigInteger = CType(goodByte, Byte)
Console.WriteLine(byteFromBigInteger)
' Convert using CByte function.
byteFromBigInteger = CByte(goodByte)
Console.WriteLine(byteFromBigInteger)

' Handle conversion that should result in overflow.
Try
   byteFromBigInteger = CType(badByte, Byte)
   Console.WriteLine(byteFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badByte, vbCrLf, e.Message)
End Try
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.

Se aplica a

Explicit(Half to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : Half -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Half) As BigInteger

Parámetros

value: Half

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Se aplica a

Explicit(Double to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : double -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Double) As BigInteger

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.

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

let doubles =
    [| Double.MinValue
       -1.430955172e03
       2.410970032e05
       Double.MaxValue
       Double.PositiveInfinity
       Double.NegativeInfinity
       Double.NaN |]

printfn "%37s %37s\n" "Double" "BigInteger"

for value in doubles do
    try
        let number = BigInteger(value)
        printfn "%37O %37O" value number
    with :? OverflowException ->
        printfn "%37O %37s" 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

Dim doubles() As Double = { Double.MinValue, -1.430955172e03, 2.410970032e05, 
                            Double.MaxValue, Double.PositiveInfinity, 
                            Double.NegativeInfinity, Double.NaN }
Dim number As BigInteger

Console.WriteLine("{0,37} {1,37}", "Double", "BigInteger")
Console.WriteLine()
For Each value As Double In doubles
   Try
      number = CType(value, BigInteger)
      Console.WriteLine("{0,37} {1,37}", value, number)
   Catch e As OverflowException
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException")
   End Try      
Next
' 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).

Se aplica a

Explicit(Decimal to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 static explicit operator System::Numerics::BigInteger(System::Decimal value);

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

static member op_Explicit : decimal -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Decimal) As BigInteger

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.

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

let decimals = [| Decimal.MinValue; -15632.991m; 9029321.12m; Decimal.MaxValue |]

printfn "%35s %35s\n" "Decimal" "BigInteger"

for value in decimals do
    let number = BigInteger(value)
    printfn "%35O %35O" value number
// The example displays the following output:
//
//                          Decimal                          BigInteger
//
//    -79228162514264337593543950335      -79228162514264337593543950335
//                       -15632.991                              -15632
//                       9029321.12                             9029321
//    79228162514264337593543950335       79228162514264337593543950335

' Explicit Decimal to BigInteger conversion
Dim decimals() As Decimal = { Decimal.MinValue, -15632.991d, 9029321.12d, 
                              Decimal.MaxValue }
Dim number As BigInteger 

Console.WriteLine("{0,35} {1,35}", "Decimal", "BigInteger")
Console.WriteLine()
For Each value As Decimal In decimals
   number = CType(value, BigInteger)
   Console.WriteLine("{0,35} {1,35}",
                     value, number)
Next
' 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).

Se aplica a

Explicit(BigInteger to Int32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

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

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

static member op_Explicit : System.Numerics.BigInteger -> int

Public Shared Narrowing Operator CType (value As BigInteger) As Integer

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.

// 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();

// BigInteger to Int32 conversion.
let goodInteger = bigint 200000
let badInteger = bigint 65000000000L

// Successful conversion using cast operator.
let integerFromBigInteger = int goodInteger
printfn $"{integerFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let integerFromBigInteger = int badInteger
    printfn $"{integerFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badInteger}:\n   {e.Message}"

' BigInteger to Int32 conversion.
Dim goodInteger As BigInteger = 200000
Dim badInteger As BigInteger = 65000000000

Dim integerFromBigInteger As Integer

' Convert using CType function.
integerFromBigInteger = CType(goodInteger, Integer)
Console.WriteLine(integerFromBigInteger)
' Convert using CInt function.
integerFromBigInteger = CInt(goodInteger)
Console.WriteLIne(integerFromBigInteger)

' Handle conversion that should result in overflow.
Try
   integerFromBigInteger = CType(badInteger, Integer)
   Console.WriteLine(integerFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badInteger, vbCrLf, e.Message)
End Try
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.

Se aplica a

Compartir vía

BigInteger.Explicit Operador

Definición

Sobrecargas

Explicit(BigInteger to SByte)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(Single to BigInteger)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(Complex to BigInteger)

Parámetros

Devoluciones

Se aplica a

Explicit(BigInteger to UIntPtr)

Parámetros

Devoluciones

Se aplica a

Explicit(BigInteger to UInt64)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to UInt32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to UInt16)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to UInt128)

Parámetros

Devoluciones

Se aplica a

Explicit(BigInteger to Single)

Parámetros

Devoluciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to IntPtr)

Parámetros

Devoluciones

Se aplica a

Explicit(BigInteger to Int64)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to Int16)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Explicit(BigInteger to Int128)

Parámetros

Devoluciones

Se aplica a

Explicit(BigInteger to Half)