BigInteger.Explicit Opérateur

Définition

Définit une conversion explicite entre un objet BigInteger et un autre type.Defines an explicit conversion between a BigInteger object and another type.

Surcharges

Explicit(Decimal to BigInteger)

Définit une conversion explicite d'un objet Decimal en valeur BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Définit une conversion explicite d'une valeur Double en valeur BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte)

Définit une conversion explicite d'un objet BigInteger en valeur d'octet non signée.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Définit une conversion explicite d'un objet BigInteger en valeur Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Définit une conversion explicite d'un objet BigInteger en valeur Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Définit une conversion explicite d'un objet BigInteger en valeur d'entier 16 bits signé.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits signé.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits signé.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Définit une conversion explicite d'un objet BigInteger en valeur 8 bits signée.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single)

Définit une conversion explicite d'un objet BigInteger en valeur à virgule flottante simple précision.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Définit une conversion explicite d'un objet BigInteger en valeur entière 16 bits non signée.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Double.The compliant alternative is Double.

Explicit(Single to BigInteger)

Définit une conversion explicite d'une valeur Single en valeur BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

Explicit(Decimal to BigInteger)

Définit une conversion explicite d'un objet Decimal en valeur 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

Paramètres

value
Decimal

Valeur à convertir en BigInteger.The value to convert to a BigInteger.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exemples

L’exemple suivant convertit les éléments individuels d’un tableau de valeurs Decimal en objets BigInteger, puis affiche le résultat de chaque conversion.The following example converts the individual elements in an array of Decimal values to BigInteger objects, and then displays the result of each conversion. Notez que toute partie fractionnaire d’une valeur Decimal est tronquée lors de la conversion.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

Remarques

Toute partie fractionnaire du paramètre value est tronquée avant la conversion.Any fractional part of the value parameter is truncated before conversion.

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Étant donné que la conversion de Decimal en BigInteger peut impliquer la troncation d’une partie fractionnaire de value, les compilateurs de langage n’effectuent pas cette conversion automatiquement.Because the conversion from Decimal to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType dans Visual Basic) est utilisé.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Pour les langages qui ne prennent pas en charge les opérateurs personnalisés, la méthode alternative est BigInteger.BigInteger(Decimal).For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Decimal).

Explicit(Double to BigInteger)

Définit une conversion explicite d'une valeur Double en valeur 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

Paramètres

value
Double

Valeur à convertir en BigInteger.The value to convert to a BigInteger.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

Exemples

L’exemple suivant convertit les éléments individuels d’un tableau de valeurs Double en objets BigInteger, puis affiche le résultat de chaque conversion.The following example converts the individual elements in an array of Double values to BigInteger objects, and then displays the result of each conversion. Notez que toute partie fractionnaire d’une valeur Double est tronquée lors de la conversion.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      

Remarques

Toute partie fractionnaire du paramètre value est tronquée avant la conversion.Any fractional part of the value parameter is truncated before conversion.

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Étant donné que la conversion de Double en BigInteger peut impliquer la troncation d’une partie fractionnaire de value, les compilateurs de langage n’effectuent pas cette conversion automatiquement.Because the conversion from Double to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType dans Visual Basic) est utilisé.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Pour les langages qui ne prennent pas en charge les opérateurs personnalisés, la méthode alternative est BigInteger.BigInteger(Double).For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Double).

Explicit(BigInteger to Byte)

Définit une conversion explicite d'un objet BigInteger en valeur d'octet non signée.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

Paramètres

value
BigInteger

Valeur à convertir en Byte.The value to convert to a Byte.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Byte.The following example illustrates the conversion of BigInteger to Byte values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données Byte.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CByte dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données Byte.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. Il n’y a aucune perte de précision dans la valeur Byte résultante si la conversion réussit.There is no loss of precision in the resulting Byte value if the conversion is successful.

Explicit(BigInteger to Decimal)

Définit une conversion explicite d'un objet BigInteger en valeur 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

Paramètres

value
BigInteger

Valeur à convertir en Decimal.The value to convert to a Decimal.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Decimal.The following example illustrates the conversion of BigInteger to Decimal values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données Decimal.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CDec dans Visual Basic) est utilisé.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.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données Decimal.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.

Explicit(BigInteger to Double)

Définit une conversion explicite d'un objet BigInteger en valeur 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

Paramètres

value
BigInteger

Valeur à convertir en Double.The value to convert to a Double.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Double.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)

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CDbl dans Visual Basic) est utilisé.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.

Étant donné que la valeur BigInteger peut être en dehors de la plage du type de données Double, cette opération est une conversion restrictive.Because the BigInteger value can be outside the range of the Double data type, this operation is a narrowing conversion. Si la conversion échoue, elle ne lève pas d' OverflowException.If the conversion is unsuccessful, it does not throw an OverflowException. Au lieu de cela, si la valeur BigInteger est inférieure à Double.MinValue, la valeur Double résultante est Double.NegativeInfinity.Instead, if the BigInteger value is less than Double.MinValue, the resulting Double value is Double.NegativeInfinity. Si la valeur de BigInteger est supérieure à Double.MaxValue, la valeur de Double résultante est Double.PositiveInfinity.If the BigInteger value is greater than Double.MaxValue, the resulting Double value is Double.PositiveInfinity.

La conversion d’un BigInteger en Double peut impliquer une perte de précision.The conversion of a BigInteger to a Double may involve a loss of precision. Dans certains cas, la perte de précision peut entraîner la aboutissement de l’opération de conversion ou de conversion, même si la valeur BigInteger est en dehors de la plage du type de données Double.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. L'exemple suivant illustre cette situation.The following example provides an illustration. Elle affecte la valeur maximale d’un Double à deux variables BigInteger, incrémente une BigInteger variable par 9.999 e291 et teste l’égalité de deux variables.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. Comme prévu, l’appel à la méthode BigInteger.Equals(BigInteger) indique qu’ils sont inégaux.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. Toutefois, la conversion de la plus grande valeur de BigInteger en Double s’effectue correctement, bien que la valeur de BigInteger dépasse à présent 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      

Explicit(BigInteger to Int16)

Définit une conversion explicite d'un objet BigInteger en valeur d'entier 16 bits signé.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

Paramètres

value
BigInteger

Valeur à convertir en entier 16 bits signé.The value to convert to a 16-bit signed integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Int16.The following example illustrates the conversion of BigInteger to Int16 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données Int16.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CShort dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données Int16.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. Il n’y a aucune perte de précision dans la valeur Int16 résultante si la conversion réussit.There is no loss of precision in the resulting Int16 value if the conversion is successful.

Explicit(BigInteger to Int32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits signé.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

Paramètres

value
BigInteger

Valeur à convertir en entier 32 bits signé.The value to convert to a 32-bit signed integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Int32.The following example illustrates the conversion of BigInteger to Int32 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données Int32.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CInt dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données Int32.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. Il n’y a aucune perte de précision dans la valeur Int16 résultante si la conversion réussit.There is no loss of precision in the resulting Int16 value if the conversion is successful.

Explicit(BigInteger to Int64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits signé.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

Paramètres

value
BigInteger

Valeur à convertir en entier 64 bits signé.The value to convert to a 64-bit signed integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Int64.The following example illustrates the conversion of BigInteger to Int64 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données Int64.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CLng dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données Int64.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.

Explicit(BigInteger to SByte)

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS
System.Int16

Définit une conversion explicite d'un objet BigInteger en valeur 8 bits signée.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int16.The compliant alternative is Int16.

public:
 static explicit operator System::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
Public Shared Narrowing Operator CType (value As BigInteger) As SByte

Paramètres

value
BigInteger

Valeur à convertir en valeur 8 bits signée.The value to convert to a signed 8-bit value.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Attributs

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs SByte.The following example illustrates the conversion of BigInteger to SByte values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données SByte.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CSByte dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données SByte.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. Il n’y a aucune perte de précision dans la valeur SByte résultante si la conversion réussit.There is no loss of precision in the resulting SByte value if the conversion is successful.

Explicit(BigInteger to Single)

Définit une conversion explicite d'un objet BigInteger en valeur à virgule flottante simple précision.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

Paramètres

value
BigInteger

Valeur à convertir en valeur à virgule flottante simple précision.The value to convert to a single-precision floating-point value.

Retours

Objet qui contient la représentation la plus proche possible du paramètre value.An object that contains the closest possible representation of the value parameter.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs Single.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)

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données ou une perte de précision.Language compilers do not perform this conversion automatically because it can involve data loss or a loss of precision. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CSng dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que la valeur BigInteger peut être en dehors de la plage du type de données Single, cette opération est une conversion restrictive.Because the BigInteger value can be outside the range of the Single data type, this operation is a narrowing conversion. Si la conversion échoue, elle ne lève pas d' OverflowException.If the conversion is unsuccessful, it does not throw an OverflowException. Au lieu de cela, si la valeur BigInteger est inférieure à Single.MinValue, la valeur Single résultante est Single.NegativeInfinity.Instead, if the BigInteger value is less than Single.MinValue, the resulting Single value is Single.NegativeInfinity. Si la valeur de BigInteger est supérieure à Single.MaxValue, la valeur de Single résultante est Single.PositiveInfinity.If the BigInteger value is greater than Single.MaxValue, the resulting Single value is Single.PositiveInfinity.

La conversion d’un BigInteger en Single peut impliquer une perte de précision.The conversion of a BigInteger to a Single may involve a loss of precision. Dans certains cas, la perte de précision peut entraîner la aboutissement de l’opération de conversion ou de conversion, même si la valeur BigInteger est en dehors de la plage du type de données Single.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. L'exemple suivant illustre cette situation.The following example provides an illustration. Elle affecte la valeur maximale d’un Single à deux variables BigInteger, incrémente une BigInteger variable par 9.999 e291 et teste l’égalité de deux variables.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. Comme prévu, l’appel à la méthode BigInteger.Equals(BigInteger) indique qu’ils sont inégaux.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. Toutefois, la conversion de la plus grande valeur de BigInteger en Single s’effectue correctement, bien que la valeur de BigInteger dépasse à présent 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

Explicit(BigInteger to UInt16)

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS
System.Int32

Définit une conversion explicite d'un objet BigInteger en valeur entière 16 bits non signée.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int32.The compliant alternative is Int32.

public:
 static explicit operator System::UInt16(System::Numerics::BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator ushort (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint16
Public Shared Narrowing Operator CType (value As BigInteger) As UShort

Paramètres

value
BigInteger

Valeur à convertir en entier 16 bits non signé.The value to convert to an unsigned 16-bit integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Attributs

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs UInt16.The following example illustrates the conversion of BigInteger to UInt16 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données UInt16.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CUShort dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données UInt16.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. Il n’y a aucune perte de précision dans la valeur UInt16 résultante si la conversion réussit.There is no loss of precision in the resulting UInt16 value if the conversion is successful.

Explicit(BigInteger to UInt32)

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS
System.Int64

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int64.The compliant alternative is Int64.

public:
 static explicit operator System::UInt32(System::Numerics::BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator uint (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint32
Public Shared Narrowing Operator CType (value As BigInteger) As UInteger

Paramètres

value
BigInteger

Valeur à convertir en entier 32 bits non signé.The value to convert to an unsigned 32-bit integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Attributs

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs UInt32.The following example illustrates the conversion of BigInteger to UInt32 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données UInt32.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CUInt dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données UInt32.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. Il n’y a aucune perte de précision dans la valeur UInt32 résultante si la conversion réussit.There is no loss of precision in the resulting UInt32 value if the conversion is successful.

Explicit(BigInteger to UInt64)

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS
System.Double

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Double.The compliant alternative is Double.

public:
 static explicit operator System::UInt64(System::Numerics::BigInteger value);
[System.CLSCompliant(false)]
public static explicit operator ulong (System.Numerics.BigInteger value);
static member op_Explicit : System.Numerics.BigInteger -> uint64
Public Shared Narrowing Operator CType (value As BigInteger) As ULong

Paramètres

value
BigInteger

Valeur à convertir en entier 64 bits non signé.The value to convert to an unsigned 64-bit integer.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Attributs

Exceptions

value est inférieur à MinValue ou supérieur à MaxValue.value is less than MinValue or is greater than MaxValue.

Exemples

L’exemple suivant illustre la conversion de BigInteger en valeurs UInt64.The following example illustrates the conversion of BigInteger to UInt64 values. Il gère également une OverflowException levée, car la valeur de BigInteger est en dehors de la plage du type de données UInt64.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()

Remarques

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut impliquer une perte de données.Language compilers do not perform this conversion automatically because it can involve data loss. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType ou CULng dans Visual Basic) est utilisé.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. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Étant donné que cette opération définit une conversion restrictive, elle peut lever une OverflowException au moment de l’exécution si la BigInteger valeur est en dehors de la plage du type de données UInt64.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. Il n’y a aucune perte de précision dans la valeur UInt64 résultante si la conversion réussit.There is no loss of precision in the resulting UInt64 value if the conversion is successful.

Explicit(Single to BigInteger)

Définit une conversion explicite d'une valeur Single en valeur 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

Paramètres

value
Single

Valeur à convertir en BigInteger.The value to convert to a BigInteger.

Retours

Objet qui contient la valeur du paramètre value.An object that contains the value of the value parameter.

Exceptions

Exemples

L’exemple suivant convertit les éléments individuels d’un tableau de valeurs Single en objets BigInteger, puis affiche le résultat de chaque conversion.The following example converts the individual elements in an array of Single values to BigInteger objects, and then displays the result of each conversion. Notez que toute partie fractionnaire d’une valeur Single est tronquée lors de la conversion.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      

Remarques

Toute partie fractionnaire du paramètre value est tronquée avant la conversion.Any fractional part of the value parameter is truncated before conversion.

Les surcharges de la méthode Explicit(Decimal to BigInteger) définissent les types vers lesquels ou à partir desquels un objet BigInteger peut être converti.The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Étant donné que la conversion de Single en BigInteger peut impliquer la troncation d’une partie fractionnaire de value, les compilateurs de langage n’effectuent pas cette conversion automatiquement.Because the conversion from Single to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Au lieu de cela, ils effectuent la conversion uniquement si un C#opérateur de cast (en) ou une fonction de conversion (comme CType dans Visual Basic) est utilisé.Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Dans le cas contraire, ils affichent une erreur du compilateur.Otherwise, they display a compiler error.

Pour les langages qui ne prennent pas en charge les opérateurs personnalisés, la méthode alternative est BigInteger.BigInteger(Single).For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Single).

S’applique à