BigInteger.Explicit Operatore

Definizione

Spazio dei nomi:: System.Numerics

Assembly:: netstandard.dll, System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Definisce una conversione esplicita tra un BigInteger oggetto e un altro tipo.

Overload

Nome	Descrizione
Explicit(BigInteger to BFloat16)
Explicit(Single to BigInteger)	Definisce una conversione esplicita di un Single valore in un BigInteger valore.
Explicit(Complex to BigInteger)	Converte in modo esplicito un Complex valore in un intero grande.
Explicit(BigInteger to UIntPtr)	Converte in modo esplicito un intero grande in un UIntPtr valore.
Explicit(BigInteger to UInt64)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 64 bit. Questa API non è conforme a CLS. L'alternativa conforme è Double.
Explicit(BigInteger to UInt32)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 32 bit. Questa API non è conforme a CLS. L'alternativa conforme è Int64.
Explicit(BigInteger to UInt16)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 16 bit. Questa API non è conforme a CLS. L'alternativa conforme è Int32.
Explicit(BigInteger to UInt128)	Converte in modo esplicito un intero grande in un UInt128 valore.
Explicit(BigInteger to Single)	Definisce una conversione esplicita di un BigInteger oggetto in un valore a virgola mobile a precisione singola.
Explicit(BigInteger to SByte)	Definisce una conversione esplicita di un BigInteger oggetto in un valore a 8 bit con segno. Questa API non è conforme a CLS. L'alternativa conforme è Int16.
Explicit(BigInteger to Int64)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 64 bit.
Explicit(BigInteger to IntPtr)	Converte in modo esplicito un intero grande in un IntPtr valore.
Explicit(BigInteger to Int16)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 16 bit.
Explicit(BigInteger to Int128)	Converte in modo esplicito un intero grande in un Int128 valore.
Explicit(BigInteger to Half)	Converte in modo esplicito un intero grande in un Half valore.
Explicit(BigInteger to Double)	Definisce una conversione esplicita di un BigInteger oggetto in un Double valore.
Explicit(BigInteger to Decimal)	Definisce una conversione esplicita di un BigInteger oggetto in un Decimal valore.
Explicit(BigInteger to Char)	Converte in modo esplicito un intero grande in un Char valore.
Explicit(BigInteger to Byte)	Definisce una conversione esplicita di un BigInteger oggetto in un valore di byte senza segno.
Explicit(BFloat16 to BigInteger)
Explicit(Half to BigInteger)	Converte in modo esplicito un Half valore in un intero grande.
Explicit(Double to BigInteger)	Definisce una conversione esplicita di un Double valore in un BigInteger valore.
Explicit(Decimal to BigInteger)	Definisce una conversione esplicita di un Decimal oggetto in un BigInteger valore.
Explicit(BigInteger to Int32)	Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 32 bit.

Explicit(BigInteger to BFloat16)

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

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

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

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

Parametri

value: BigInteger

Restituisce

BFloat16

Si applica a

Explicit(Single to BigInteger)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un Single valore in un BigInteger valore.

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

Parametri

value: Single

Valore da convertire in un oggetto BigInteger.

Restituisce

BigInteger

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è NaN, PositiveInfinityo NegativeInfinity.

Esempio

L'esempio seguente converte i singoli elementi in una matrice di Single valori in BigInteger oggetti e quindi visualizza il risultato di ogni conversione. Si noti che qualsiasi parte frazionaria di un Single valore viene troncata durante la conversione.

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

Commenti

Qualsiasi parte frazionaria del parametro viene troncata prima della value conversione.

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. Poiché la conversione da Single a BigInteger può comportare il troncamento di qualsiasi parte frazionaria di , i compilatori del valuelinguaggio non eseguono automaticamente questa conversione. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Per i linguaggi che non supportano operatori personalizzati, il metodo alternativo è BigInteger.BigInteger(Single).

Si applica a

Explicit(Complex to BigInteger)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un Complex valore in un intero 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

Parametri

value: Complex

Valore da convertire.

Restituisce

BigInteger

value convertito in un intero grande.

Si applica a

Explicit(BigInteger to UIntPtr)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Converte in modo esplicito un intero grande in un UIntPtr valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

UIntPtr

unativeint

value convertito in UIntPtr valore.

Attributi: CLSCompliantAttribute

Si applica a

Explicit(BigInteger to UInt64)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS: System.Double

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 64 bit.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value: BigInteger

Valore da convertire in un intero senza segno a 64 bit.

Restituisce

UInt64

Oggetto che contiene il valore del value parametro .

Attributi: CLSCompliantAttribute

Eccezioni

OverflowException

value è minore di UInt64.MinValue o è maggiore di UInt64.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in UInt64 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del UInt64 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CULng in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del UInt64 tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante UInt64 .

Si applica a

Explicit(BigInteger to UInt32)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS: System.Int64

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 32 bit.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value: BigInteger

Valore da convertire in un intero senza segno a 32 bit.

Restituisce

UInt32

Oggetto che contiene il valore del value parametro .

Attributi: CLSCompliantAttribute

Eccezioni

OverflowException

value è minore di UInt32.MinValue o è maggiore di UInt32.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in UInt32 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del UInt32 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CUInt in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del UInt32 tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante UInt32 .

Si applica a

Explicit(BigInteger to UInt16)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS: System.Int32

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero senza segno a 16 bit.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value: BigInteger

Valore da convertire in un intero senza segno a 16 bit.

Restituisce

UInt16

Oggetto che contiene il valore del value parametro .

Attributi: CLSCompliantAttribute

Eccezioni

OverflowException

value è minore di UInt16.MinValue o è maggiore di UInt16.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in UInt16 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del UInt16 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CUShort in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del UInt16 tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante UInt16 .

Si applica a

Explicit(BigInteger to UInt128)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Converte in modo esplicito un intero grande in un UInt128 valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

UInt128

value convertito in UInt128 valore.

Attributi: CLSCompliantAttribute

Si applica a

Explicit(BigInteger to Single)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un valore a virgola mobile a precisione singola.

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

Parametri

value: BigInteger

Valore da convertire in un valore a virgola mobile e precisione singola.

Restituisce

Single

Oggetto contenente la rappresentazione più vicina possibile del value parametro.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Single valori .

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati o una perdita di precisione. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CSng in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché il BigInteger valore può essere esterno all'intervallo del Single tipo di dati, questa operazione è una conversione verso un tipo di dati più piccolo. Se la conversione non riesce, non genera un'eccezione OverflowException. Se invece il BigInteger valore è minore di Single.MinValue, il valore risultante Single è Single.NegativeInfinity. Se il BigInteger valore è maggiore di Single.MaxValue, il valore risultante Single è Single.PositiveInfinity.

La conversione di un BigInteger oggetto in può Single comportare una perdita di precisione. In alcuni casi, la perdita di precisione può causare l'esito positivo dell'operazione di cast o conversione anche se il BigInteger valore non rientra nell'intervallo del Single tipo di dati. Di seguito ne viene illustrato un esempio. Assegna il valore massimo di a Single due BigInteger variabili, incrementa una BigInteger variabile di 9,999e291 e testa le due variabili per verificarne l'uguaglianza. Come previsto, la chiamata al BigInteger.Equals(BigInteger) metodo mostra che non sono uguali. Tuttavia, la conversione del valore maggiore in un Single oggetto ha esito positivo, anche se il BigInteger valore ora 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

Si applica a

Explicit(BigInteger to SByte)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS: System.Int16

Definisce una conversione esplicita di un BigInteger oggetto in un valore a 8 bit con segno.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value: BigInteger

Valore da convertire in un valore a 8 bit con segno.

Restituisce

SByte

Oggetto che contiene il valore del value parametro .

Attributi: CLSCompliantAttribute

Eccezioni

OverflowException

value è minore di SByte.MinValue o è maggiore di SByte.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in SByte valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del SByte tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CSByte in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del SByte tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante SByte .

Si applica a

Explicit(BigInteger to Int64)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 64 bit.

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

Parametri

value: BigInteger

Valore da convertire in un intero con segno a 64 bit.

Restituisce

Int64

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è minore di Int64.MinValue o è maggiore di Int64.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Int64 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del Int64 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CLng in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Si applica a

Explicit(BigInteger to IntPtr)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un intero grande in un IntPtr valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

IntPtr

nativeint

value convertito in IntPtr valore.

Si applica a

Explicit(BigInteger to Int16)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 16 bit.

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

Parametri

value: BigInteger

Valore da convertire in un intero con segno a 16 bit.

Restituisce

Int16

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è minore di Int16.MinValue o è maggiore di Int16.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Int16 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del Int16 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CShort in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del Int16 tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante Int16 .

Si applica a

Explicit(BigInteger to Int128)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un intero grande in un Int128 valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

Int128

value convertito in Int128 valore.

Si applica a

Explicit(BigInteger to Half)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un intero grande in un Half valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

Half

value convertito in Half valore.

Si applica a

Explicit(BigInteger to Double)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un Double valore.

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

Parametri

value: BigInteger

Valore da convertire in un oggetto Double.

Restituisce

Double

Oggetto che contiene il valore del value parametro .

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Double valori .

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

Commenti

Poiché il BigInteger valore può essere esterno all'intervallo del Double tipo di dati, questa operazione è una conversione verso un tipo di dati più piccolo. Se la conversione non riesce, non genera un'eccezione OverflowException. Se invece il BigInteger valore è minore di Double.MinValue, il valore risultante Double è Double.NegativeInfinity. Se il BigInteger valore è maggiore di Double.MaxValue, il valore risultante Double è Double.PositiveInfinity.

La conversione di un BigInteger oggetto in può Double comportare una perdita di precisione. In alcuni casi, la perdita di precisione può causare l'esito positivo dell'operazione di cast o conversione anche se il BigInteger valore non rientra nell'intervallo del Double tipo di dati. Di seguito ne viene illustrato un esempio. Assegna il valore massimo di a Double due BigInteger variabili, incrementa una BigInteger variabile di 9,999e291 e testa le due variabili per verificarne l'uguaglianza. Come previsto, la chiamata al BigInteger.Equals(BigInteger) metodo mostra che non sono uguali. Tuttavia, la conversione del valore maggiore in un Double oggetto ha esito positivo, anche se il BigInteger valore ora 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

Si applica a

Explicit(BigInteger to Decimal)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un Decimal valore.

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

Parametri

value: BigInteger

Valore da convertire in un oggetto Decimal.

Restituisce

Decimal

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è minore di Decimal.MinValue o maggiore di Decimal.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Decimal valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del Decimal tipo di dati.

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

Commenti

Si applica a

Explicit(BigInteger to Char)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un intero grande in un Char valore.

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

Parametri

value: BigInteger

Valore da convertire.

Restituisce

Char

value convertito in Char valore.

Si applica a

Explicit(BigInteger to Byte)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un valore di byte senza segno.

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

Parametri

value: BigInteger

Valore da convertire in un oggetto Byte.

Restituisce

Byte

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è minore di Byte.MinValue o maggiore di Byte.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Byte valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del Byte tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CByte in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del Byte tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante Byte .

Si applica a

Explicit(BFloat16 to BigInteger)

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

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

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

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

Parametri

value: BFloat16

Restituisce

BigInteger

Si applica a

Explicit(Half to BigInteger)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Converte in modo esplicito un Half valore in un intero 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

Parametri

value: Half

Valore da convertire.

Restituisce

BigInteger

value convertito in un intero grande.

Si applica a

Explicit(Double to BigInteger)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un Double valore in un BigInteger valore.

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

Parametri

value: Double

Valore da convertire in un oggetto BigInteger.

Restituisce

BigInteger

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è NaN, PositiveInfinityo NegativeInfinity.

Esempio

L'esempio seguente converte i singoli elementi in una matrice di Double valori in BigInteger oggetti e quindi visualizza il risultato di ogni conversione. Si noti che qualsiasi parte frazionaria di un Double valore viene troncata durante la conversione.

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

Commenti

Qualsiasi parte frazionaria del parametro viene troncata prima della value conversione.

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. Poiché la conversione da Double a BigInteger può comportare il troncamento di qualsiasi parte frazionaria di , i compilatori del valuelinguaggio non eseguono automaticamente questa conversione. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Per i linguaggi che non supportano operatori personalizzati, il metodo alternativo è BigInteger.BigInteger(Double).

Si applica a

Explicit(Decimal to BigInteger)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un Decimal oggetto in un BigInteger valore.

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

Parametri

value: Decimal

Valore da convertire in un oggetto BigInteger.

Restituisce

BigInteger

Oggetto che contiene il valore del value parametro .

Esempio

L'esempio seguente converte i singoli elementi in una matrice di Decimal valori in BigInteger oggetti e quindi visualizza il risultato di ogni conversione. Si noti che qualsiasi parte frazionaria di un Decimal valore viene troncata durante la conversione.

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

Commenti

Qualsiasi parte frazionaria del parametro viene troncata prima della value conversione.

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. Poiché la conversione da Decimal a BigInteger può comportare il troncamento di qualsiasi parte frazionaria di , i compilatori del valuelinguaggio non eseguono automaticamente questa conversione. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Per i linguaggi che non supportano operatori personalizzati, il metodo alternativo è BigInteger.BigInteger(Decimal).

Si applica a

Explicit(BigInteger to Int32)

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Origine:: BigInteger.cs

Definisce una conversione esplicita di un BigInteger oggetto in un valore intero con segno a 32 bit.

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

Parametri

value: BigInteger

Valore da convertire in un intero con segno a 32 bit.

Restituisce

Int32

Oggetto che contiene il valore del value parametro .

Eccezioni

OverflowException

value è minore di Int32.MinValue o è maggiore di Int32.MaxValue.

Esempio

Nell'esempio seguente viene illustrata la conversione di BigInteger in Int32 valori . Gestisce anche un OverflowException oggetto generato perché il BigInteger valore non rientra nell'intervallo del Int32 tipo di dati.

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

Commenti

Gli overload del Explicit(Decimal to BigInteger) metodo definiscono i tipi in cui o da cui è possibile convertire un BigInteger oggetto. I compilatori del linguaggio non eseguono questa conversione automaticamente perché possono comportare la perdita di dati. Eseguono invece la conversione solo se viene usato un operatore di cast (in C#) o una funzione di conversione (ad esempio CType o CInt in Visual Basic). In caso contrario, visualizzano un errore del compilatore.

Poiché questa operazione definisce una conversione di tipo narrowing, può generare un'eccezione OverflowException in fase di esecuzione se il BigInteger valore non rientra nell'intervallo del Int32 tipo di dati. Se la conversione ha esito positivo, non si verifica alcuna perdita di precisione nel valore risultante Int32 .

Si applica a

Valutazione

Questa pagina ti è stata utile?

Condividi tramite

BigInteger.Explicit Operatore

Definizione

Overload

Explicit(BigInteger to BFloat16)

Parametri

Restituisce

Si applica a

Explicit(Single to BigInteger)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(Complex to BigInteger)

Parametri

Restituisce

Si applica a

Explicit(BigInteger to UIntPtr)

Parametri

Restituisce

Si applica a

Explicit(BigInteger to UInt64)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to UInt32)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to UInt16)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to UInt128)

Parametri

Restituisce

Si applica a

Explicit(BigInteger to Single)

Parametri

Restituisce

Esempio

Commenti

Si applica a

Explicit(BigInteger to SByte)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to Int64)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to IntPtr)

Parametri

Restituisce

Si applica a

Explicit(BigInteger to Int16)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Explicit(BigInteger to Int128)