BigInteger.Explicit Operador

Definição

Define uma conversão explícita entre um objeto BigInteger e outro tipo.Defines an explicit conversion between a BigInteger object and another type.

Sobrecargas

Explicit(BigInteger to UInt64)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 64 bits.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Double.The compliant alternative is Double.

Explicit(BigInteger to UInt32)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 32 bits.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt16)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 16 bits.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int32.The compliant alternative is Int32.

Explicit(BigInteger to Single)

Define uma conversão explícita de um objeto BigInteger em um valor de ponto flutuante de precisão simples.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to SByte)

Define uma conversão explícita de um objeto BigInteger em um valor de 8 bits com sinal.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int16.The compliant alternative is Int16.

Explicit(BigInteger to Int64)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 64 bits.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(Single to BigInteger)

Define uma conversão explícita de um valor Single para um valor BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

Explicit(BigInteger to Int16)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro com sinal de 16 bits.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Double)

Define uma conversão explícita de um objeto BigInteger em um valor Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Decimal)

Define uma conversão explícita de um objeto BigInteger em um valor Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Byte)

Define uma conversão explícita de um objeto BigInteger em um valor de byte sem sinal.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(Double to BigInteger)

Define uma conversão explícita de um valor Double para um valor BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Decimal to BigInteger)

Define uma conversão explícita de um objeto Decimal em um valor BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(BigInteger to Int32)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 32 bits.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to UInt64)

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Double

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 64 bits.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Double.The compliant alternative is Double.

public:
 static explicit operator System::UInt64(System::Numerics::BigInteger value);
public static explicit operator ulong (System.Numerics.BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator ulong (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint64
[<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

O valor a ser convertido em um inteiro sem sinal de 64 bits.The value to convert to an unsigned 64-bit integer.

Retornos

UInt64

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Atributos

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para UInt64 valores.The following example illustrates the conversion of BigInteger to UInt64 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do UInt64 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt64 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CULng em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CULng in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do UInt64 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt64 data type. Não haverá perda de precisão no UInt64 valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting UInt64 value if the conversion is successful.

Aplica-se a

Explicit(BigInteger to UInt32)

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Int64

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 32 bits.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int64.The compliant alternative is Int64.

public:
 static explicit operator System::UInt32(System::Numerics::BigInteger value);
public static explicit operator uint (System.Numerics.BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator uint (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint32
[<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

O valor a ser convertido em um inteiro sem sinal de 32 bits.The value to convert to an unsigned 32-bit integer.

Retornos

UInt32

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Atributos

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para UInt32 valores.The following example illustrates the conversion of BigInteger to UInt32 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do UInt32 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt32 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CUInt em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CUInt in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do UInt32 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt32 data type. Não haverá perda de precisão no UInt32 valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting UInt32 value if the conversion is successful.

Aplica-se a

Explicit(BigInteger to UInt16)

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Int32

Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 16 bits.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int32.The compliant alternative is Int32.

public:
 static explicit operator System::UInt16(System::Numerics::BigInteger value);
public static explicit operator ushort (System.Numerics.BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator ushort (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint16
[<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

O valor a ser convertido em um inteiro sem sinal de 16 bits.The value to convert to an unsigned 16-bit integer.

Retornos

UInt16

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Atributos

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para UInt16 valores.The following example illustrates the conversion of BigInteger to UInt16 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do UInt16 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt16 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CUShort em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CUShort in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do UInt16 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt16 data type. Não haverá perda de precisão no UInt16 valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting UInt16 value if the conversion is successful.

Aplica-se a

Explicit(BigInteger to Single)

Define uma conversão explícita de um objeto BigInteger em um valor de ponto flutuante de precisão simples.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

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

O valor a ser convertido em um ponto flutuante de precisão simples.The value to convert to a single-precision floating-point value.

Retornos

Single

Um objeto que contém a representação mais próxima possível do parâmetro value.An object that contains the closest possible representation of the value parameter.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Single valores.The following example illustrates the conversion of BigInteger to Single values.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados ou uma perda de precisão.Language compilers do not perform this conversion automatically because it can involve data loss or a loss of precision. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CSng em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CSng in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como o BigInteger valor pode estar fora do intervalo do Single tipo de dados, essa operação é uma conversão de restrição.Because the BigInteger value can be outside the range of the Single data type, this operation is a narrowing conversion. Se a conversão não for bem-sucedida, ela não lançará um OverflowException .If the conversion is unsuccessful, it does not throw an OverflowException. Em vez disso, se o BigInteger valor for menor que Single.MinValue , o Single valor resultante será Single.NegativeInfinity .Instead, if the BigInteger value is less than Single.MinValue, the resulting Single value is Single.NegativeInfinity. Se o BigInteger valor for maior que Single.MaxValue , o Single valor resultante será Single.PositiveInfinity .If the BigInteger value is greater than Single.MaxValue, the resulting Single value is Single.PositiveInfinity.

A conversão de a BigInteger para a Single pode envolver uma perda de precisão.The conversion of a BigInteger to a Single may involve a loss of precision. Em alguns casos, a perda de precisão pode fazer com que a operação de conversão ou de converter tenha sucesso mesmo que o BigInteger valor esteja fora do intervalo do Single tipo de dados.In some cases, the loss of precision may cause the casting or conversion operation to succeed even if the BigInteger value is outside the range of the Single data type. O exemplo a seguir fornece uma ilustração.The following example provides an illustration. Ele atribui o valor máximo de uma Single a duas BigInteger variáveis, incrementa uma BigInteger variável por 9.999 e291 e testa as duas variáveis para igualdade.It assigns the maximum value of a Single to two BigInteger variables, increments one BigInteger variable by 9.999e291, and tests the two variables for equality. Como esperado, a chamada para o BigInteger.Equals(BigInteger) método mostra que eles são desiguais.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. No entanto, a conversão do BigInteger valor maior de volta para um é Single bem sucedido, embora o BigInteger valor agora exceda Single.MaxValue .However, the conversion of the larger BigInteger value back to a Single succeeds, although the BigInteger value now exceeds Single.MaxValue.

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

Aplica-se a

Explicit(BigInteger to SByte)

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Int16

Define uma conversão explícita de um objeto BigInteger em um valor de 8 bits com sinal.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Esta API não compatível com CLS.This API is not CLS-compliant. A alternativa em conformidade é Int16.The compliant alternative is Int16.

public:
 static explicit operator System::SByte(System::Numerics::BigInteger value);
public static explicit operator sbyte (System.Numerics.BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator sbyte (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> sbyte
[<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

O valor a ser convertido em um valor de 8 bits com sinal.The value to convert to a signed 8-bit value.

Retornos

SByte

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Atributos

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para SByte valores.The following example illustrates the conversion of BigInteger to SByte values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do SByte tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the SByte data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CSByte em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CSByte in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do SByte tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the SByte data type. Não haverá perda de precisão no SByte valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting SByte value if the conversion is successful.

Aplica-se a

Explicit(BigInteger to Int64)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 64 bits.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

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

O valor a ser convertido em um inteiro com sinal de 64 bits.The value to convert to a 64-bit signed integer.

Retornos

Int64

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Int64 valores.The following example illustrates the conversion of BigInteger to Int64 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do Int64 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int64 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CLng em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CLng in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do Int64 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int64 data type.

Aplica-se a

Explicit(Single to BigInteger)

Define uma conversão explícita de um valor Single para um valor BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

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

O valor a ser convertido para um BigInteger.The value to convert to a BigInteger.

Retornos

BigInteger

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

Exemplos

O exemplo a seguir converte os elementos individuais em uma matriz de Single valores em BigInteger objetos e, em seguida, exibe o resultado de cada conversão.The following example converts the individual elements in an array of Single values to BigInteger objects, and then displays the result of each conversion. Observe que qualquer parte fracionária de um Single valor é truncada durante a conversão.Note that any fractional part of a Single value is truncated during the conversion.

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

Comentários

Qualquer parte fracionária do value parâmetro é truncada antes da conversão.Any fractional part of the value parameter is truncated before conversion.

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Como a conversão do Single para BigInteger pode envolver o truncamento de qualquer parte fracionária do value , os compiladores de linguagem não executam essa conversão automaticamente.Because the conversion from Single to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Para idiomas que não dão suporte a operadores personalizados, o método alternativo é BigInteger.BigInteger(Single) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Single).

Aplica-se a

Explicit(BigInteger to Int16)

Define uma conversão explícita de um objeto BigInteger em um valor inteiro com sinal de 16 bits.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

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

O valor a ser convertido em um inteiro com sinal de 16 bits.The value to convert to a 16-bit signed integer.

Retornos

Int16

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Int16 valores.The following example illustrates the conversion of BigInteger to Int16 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do Int16 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int16 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CShort em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CShort in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do Int16 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int16 data type. Não haverá perda de precisão no Int16 valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting Int16 value if the conversion is successful.

Aplica-se a

Explicit(BigInteger to Double)

Define uma conversão explícita de um objeto BigInteger em um valor Double.Defines an explicit conversion of a BigInteger object to a Double value.

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

O valor a ser convertido para um Double.The value to convert to a Double.

Retornos

Double

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Double valores.The following example illustrates the conversion of BigInteger to Double values.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CDbl em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CDbl in Visual Basic) is used.

Como o BigInteger valor pode estar fora do intervalo do Double tipo de dados, essa operação é uma conversão de restrição.Because the BigInteger value can be outside the range of the Double data type, this operation is a narrowing conversion. Se a conversão não for bem-sucedida, ela não lançará um OverflowException .If the conversion is unsuccessful, it does not throw an OverflowException. Em vez disso, se o BigInteger valor for menor que Double.MinValue , o Double valor resultante será Double.NegativeInfinity .Instead, if the BigInteger value is less than Double.MinValue, the resulting Double value is Double.NegativeInfinity. Se o BigInteger valor for maior que Double.MaxValue , o Double valor resultante será Double.PositiveInfinity .If the BigInteger value is greater than Double.MaxValue, the resulting Double value is Double.PositiveInfinity.

A conversão de a BigInteger para a Double pode envolver uma perda de precisão.The conversion of a BigInteger to a Double may involve a loss of precision. Em alguns casos, a perda de precisão pode fazer com que a operação de conversão ou de converter tenha sucesso mesmo que o BigInteger valor esteja fora do intervalo do Double tipo de dados.In some cases, the loss of precision may cause the casting or conversion operation to succeed even if the BigInteger value is outside the range of the Double data type. O exemplo a seguir fornece uma ilustração.The following example provides an illustration. Ele atribui o valor máximo de uma Double a duas BigInteger variáveis, incrementa uma BigInteger variável por 9.999 e291 e testa as duas variáveis para igualdade.It assigns the maximum value of a Double to two BigInteger variables, increments one BigInteger variable by 9.999e291, and tests the two variables for equality. Como esperado, a chamada para o BigInteger.Equals(BigInteger) método mostra que eles são desiguais.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. No entanto, a conversão do BigInteger valor maior de volta para um é Double bem sucedido, embora o BigInteger valor agora exceda Double.MaxValue .However, the conversion of the larger BigInteger value back to a Double succeeds, although the BigInteger value now exceeds Double.MaxValue.

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

Aplica-se a

Explicit(BigInteger to Decimal)

Define uma conversão explícita de um objeto BigInteger em um valor Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

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

O valor a ser convertido para um Decimal.The value to convert to a Decimal.

Retornos

Decimal

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Decimal valores.The following example illustrates the conversion of BigInteger to Decimal values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do Decimal tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Decimal data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CDec em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CDec in Visual Basic) is used.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do Decimal tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Decimal data type.

Aplica-se a

Explicit(BigInteger to Byte)

Define uma conversão explícita de um objeto BigInteger em um valor de byte sem sinal.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

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

O valor a ser convertido para um Byte.The value to convert to a Byte.

Retornos

Byte

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Byte valores.The following example illustrates the conversion of BigInteger to Byte values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do Byte tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Byte data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CByte em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CByte in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do Byte tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Byte data type. Não haverá perda de precisão no Byte valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting Byte value if the conversion is successful.

Aplica-se a

Explicit(Double to BigInteger)

Define uma conversão explícita de um valor Double para um valor BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

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

O valor a ser convertido para um BigInteger.The value to convert to a BigInteger.

Retornos

BigInteger

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

Exemplos

O exemplo a seguir converte os elementos individuais em uma matriz de Double valores em BigInteger objetos e, em seguida, exibe o resultado de cada conversão.The following example converts the individual elements in an array of Double values to BigInteger objects, and then displays the result of each conversion. Observe que qualquer parte fracionária de um Double valor é truncada durante a conversão.Note that any fractional part of a Double value is truncated during the conversion.

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

Comentários

Qualquer parte fracionária do value parâmetro é truncada antes da conversão.Any fractional part of the value parameter is truncated before conversion.

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Como a conversão do Double para BigInteger pode envolver o truncamento de qualquer parte fracionária do value , os compiladores de linguagem não executam essa conversão automaticamente.Because the conversion from Double to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Para idiomas que não dão suporte a operadores personalizados, o método alternativo é BigInteger.BigInteger(Double) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Double).

Aplica-se a

Explicit(Decimal to BigInteger)

Define uma conversão explícita de um objeto Decimal em um valor BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

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

O valor a ser convertido para um BigInteger.The value to convert to a BigInteger.

Retornos

BigInteger

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exemplos

O exemplo a seguir converte os elementos individuais em uma matriz de Decimal valores em BigInteger objetos e, em seguida, exibe o resultado de cada conversão.The following example converts the individual elements in an array of Decimal values to BigInteger objects, and then displays the result of each conversion. Observe que qualquer parte fracionária de um Decimal valor é truncada durante a conversão.Note that any fractional part of a Decimal value is truncated during the conversion.

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

Comentários

Qualquer parte fracionária do value parâmetro é truncada antes da conversão.Any fractional part of the value parameter is truncated before conversion.

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Como a conversão do Decimal para BigInteger pode envolver o truncamento de qualquer parte fracionária do value , os compiladores de linguagem não executam essa conversão automaticamente.Because the conversion from Decimal to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Para idiomas que não dão suporte a operadores personalizados, o método alternativo é BigInteger.BigInteger(Decimal) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Decimal).

Aplica-se a

Explicit(BigInteger to Int32)

Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 32 bits.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

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

O valor a ser convertido em um inteiro com sinal de 32 bits.The value to convert to a 32-bit signed integer.

Retornos

Int32

Um objeto que contém o valor do parâmetro value.An object that contains the value of the value parameter.

Exceções

value é menor que MinValue ou maior que MaxValue.value is less than MinValue or is greater than MaxValue.

Exemplos

O exemplo a seguir ilustra a conversão de BigInteger para Int32 valores.The following example illustrates the conversion of BigInteger to Int32 values. Ele também trata de um OverflowException que é gerado porque o BigInteger valor está fora do intervalo do Int32 tipo de dados.It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int32 data type.

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

Comentários

As sobrecargas do Explicit(Decimal to BigInteger) método definem os tipos para os quais ou de onde um BigInteger objeto pode ser convertido.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Os compiladores de linguagem não executam essa conversão automaticamente porque podem envolver a perda de dados.Language compilers do not perform this conversion automatically because it can involve data loss. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType ou CInt em Visual Basic) for usado.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CInt in Visual Basic) is used. Caso contrário, eles exibirão um erro do compilador.Otherwise, they display a compiler error.

Como essa operação define uma conversão de restrição, ela pode lançar um OverflowException em tempo de execução se o BigInteger valor estiver fora do intervalo do Int32 tipo de dados.Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int32 data type. Não haverá perda de precisão no Int32 valor resultante se a conversão for bem-sucedida.There is no loss of precision in the resulting Int32 value if the conversion is successful.

Aplica-se a