BigInteger.Explicit Оператор

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

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

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

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

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

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

Параметры

Возвращаемое значение

UInt64

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Атрибуты

CLSCompliantAttribute

Исключения

Примеры

В следующем примере показано преобразование BigInteger в UInt64 значения.The following example illustrates the conversion of BigInteger to UInt64 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CULng в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, UInt64 Если преобразование выполнено успешно.There is no loss of precision in the resulting UInt64 value if the conversion is successful.

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

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

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

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

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

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

Параметры

Возвращаемое значение

UInt32

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Атрибуты

CLSCompliantAttribute

Исключения

Примеры

В следующем примере показано преобразование BigInteger в UInt32 значения.The following example illustrates the conversion of BigInteger to UInt32 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CUInt в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, UInt32 Если преобразование выполнено успешно.There is no loss of precision in the resulting UInt32 value if the conversion is successful.

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

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

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

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

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

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

Параметры

Возвращаемое значение

UInt16

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Атрибуты

CLSCompliantAttribute

Исключения

Примеры

В следующем примере показано преобразование BigInteger в UInt16 значения.The following example illustrates the conversion of BigInteger to UInt16 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CUShort в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, UInt16 Если преобразование выполнено успешно.There is no loss of precision in the resulting UInt16 value if the conversion is successful.

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

Параметры

Возвращаемое значение

Single

Объект, содержащий ближайшее возможное представление параметра value.An object that contains the closest possible representation of the value parameter.

Примеры

В следующем примере показано преобразование BigInteger в 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)

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Языковые компиляторы не выполняют это преобразование автоматически, так как оно может привести к утрате данных или к утрате точности.Language compilers do not perform this conversion automatically because it can involve data loss or a loss of precision. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CSng в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как BigInteger значение может находиться вне диапазона Single типа данных, эта операция является узким преобразованием.Because the BigInteger value can be outside the range of the Single data type, this operation is a narrowing conversion. Если преобразование завершилось неудачно, оно не вызывает исключение OverflowException .If the conversion is unsuccessful, it does not throw an OverflowException. Вместо этого, если BigInteger значение меньше Single.MinValue , то результирующим Single значением является Single.NegativeInfinity .Instead, if the BigInteger value is less than Single.MinValue, the resulting Single value is Single.NegativeInfinity. Если BigInteger значение больше Single.MaxValue , то результирующее Single значение равно Single.PositiveInfinity .If the BigInteger value is greater than Single.MaxValue, the resulting Single value is Single.PositiveInfinity.

Преобразование типа в BigInteger может привести к Single утере точности.The conversion of a BigInteger to a Single may involve a loss of precision. В некоторых случаях потери точности могут привести к успешности операции приведения или преобразования, даже если BigInteger значение выходит за пределы диапазона 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. Ниже приведен пример.The following example provides an illustration. Он назначает максимальное значение Single для двух BigInteger переменных, увеличивает одну BigInteger переменную на 9.999 e291 и проверяет две переменные на равенство.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. Как и ожидалось, вызов BigInteger.Equals(BigInteger) метода показывает, что они не равны.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. Однако преобразование большего значения обратно в значение будет BigInteger Single выполнено, хотя BigInteger значение теперь превышает 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

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

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

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

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

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

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

Параметры

Возвращаемое значение

SByte

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Атрибуты

CLSCompliantAttribute

Исключения

Примеры

В следующем примере показано преобразование BigInteger в SByte значения.The following example illustrates the conversion of BigInteger to SByte values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CSByte в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, SByte Если преобразование выполнено успешно.There is no loss of precision in the resulting SByte value if the conversion is successful.

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

Параметры

Возвращаемое значение

Int64

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере показано преобразование BigInteger в Int64 значения.The following example illustrates the conversion of BigInteger to Int64 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CLng в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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.

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

Параметры

Возвращаемое значение

BigInteger

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере отдельные элементы в массиве значений преобразуются в Single BigInteger объекты, а затем выводятся результаты каждого преобразования.The following example converts the individual elements in an array of Single values to BigInteger objects, and then displays the result of each conversion. Обратите внимание, что Single во время преобразования дробная часть значения усекается.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      

Комментарии

Перед преобразованием дробная часть параметра value усекается.Any fractional part of the value parameter is truncated before conversion.

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Поскольку преобразование из Single в BigInteger может привести к усечению любой дробной части value , языковые компиляторы не выполняют это преобразование автоматически.Because the conversion from Single to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType в Visual Basic).Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Для языков, которые не поддерживают пользовательские операторы, альтернативным методом является BigInteger.BigInteger(Single) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Single).

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

Параметры

Возвращаемое значение

Int16

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере показано преобразование BigInteger в Int16 значения.The following example illustrates the conversion of BigInteger to Int16 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CShort в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, Int16 Если преобразование выполнено успешно.There is no loss of precision in the resulting Int16 value if the conversion is successful.

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

Параметры

Возвращаемое значение

Double

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Примеры

В следующем примере показано преобразование BigInteger в 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)

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CDbl в Visual Basic).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.

Так как BigInteger значение может находиться вне диапазона Double типа данных, эта операция является узким преобразованием.Because the BigInteger value can be outside the range of the Double data type, this operation is a narrowing conversion. Если преобразование завершилось неудачно, оно не вызывает исключение OverflowException .If the conversion is unsuccessful, it does not throw an OverflowException. Вместо этого, если BigInteger значение меньше Double.MinValue , то результирующим Double значением является Double.NegativeInfinity .Instead, if the BigInteger value is less than Double.MinValue, the resulting Double value is Double.NegativeInfinity. Если BigInteger значение больше Double.MaxValue , то результирующее Double значение равно Double.PositiveInfinity .If the BigInteger value is greater than Double.MaxValue, the resulting Double value is Double.PositiveInfinity.

Преобразование типа в BigInteger может привести к Double утере точности.The conversion of a BigInteger to a Double may involve a loss of precision. В некоторых случаях потери точности могут привести к успешности операции приведения или преобразования, даже если BigInteger значение выходит за пределы диапазона 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. Ниже приведен пример.The following example provides an illustration. Он назначает максимальное значение Double для двух BigInteger переменных, увеличивает одну BigInteger переменную на 9.999 e291 и проверяет две переменные на равенство.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. Как и ожидалось, вызов BigInteger.Equals(BigInteger) метода показывает, что они не равны.As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. Однако преобразование большего значения обратно в значение будет BigInteger Double выполнено, хотя BigInteger значение теперь превышает 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      

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

Параметры

Возвращаемое значение

Decimal

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере показано преобразование BigInteger в Decimal значения.The following example illustrates the conversion of BigInteger to Decimal values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CDec в Visual Basic).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.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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.

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

Параметры

Возвращаемое значение

Byte

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере показано преобразование BigInteger в Byte значения.The following example illustrates the conversion of BigInteger to Byte values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CByte в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, Byte Если преобразование выполнено успешно.There is no loss of precision in the resulting Byte value if the conversion is successful.

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

Параметры

Возвращаемое значение

BigInteger

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере отдельные элементы в массиве значений преобразуются в Double BigInteger объекты, а затем выводятся результаты каждого преобразования.The following example converts the individual elements in an array of Double values to BigInteger objects, and then displays the result of each conversion. Обратите внимание, что Double во время преобразования дробная часть значения усекается.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      

Комментарии

Перед преобразованием дробная часть параметра value усекается.Any fractional part of the value parameter is truncated before conversion.

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Поскольку преобразование из Double в BigInteger может привести к усечению любой дробной части value , языковые компиляторы не выполняют это преобразование автоматически.Because the conversion from Double to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType в Visual Basic).Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Для языков, которые не поддерживают пользовательские операторы, альтернативным методом является BigInteger.BigInteger(Double) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Double).

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

Параметры

Возвращаемое значение

BigInteger

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Примеры

В следующем примере отдельные элементы в массиве значений преобразуются в Decimal BigInteger объекты, а затем выводятся результаты каждого преобразования.The following example converts the individual elements in an array of Decimal values to BigInteger objects, and then displays the result of each conversion. Обратите внимание, что Decimal во время преобразования дробная часть значения усекается.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

Комментарии

Перед преобразованием дробная часть параметра value усекается.Any fractional part of the value parameter is truncated before conversion.

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Поскольку преобразование из Decimal в BigInteger может привести к усечению любой дробной части value , языковые компиляторы не выполняют это преобразование автоматически.Because the conversion from Decimal to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType в Visual Basic).Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Для языков, которые не поддерживают пользовательские операторы, альтернативным методом является BigInteger.BigInteger(Decimal) .For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Decimal).

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

Параметры

Возвращаемое значение

Int32

Объект, содержащий значение параметра value.An object that contains the value of the value parameter.

Исключения

Примеры

В следующем примере показано преобразование BigInteger в Int32 значения.The following example illustrates the conversion of BigInteger to Int32 values. Он также обрабатывает OverflowException исключение, вызванное тем, что BigInteger значение выходит за пределы диапазона 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()

Комментарии

Перегрузки метода Explicit(Decimal to BigInteger) определяют типы, в которых может быть преобразован объект BigInteger .The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Компиляторы языков не выполняют это преобразование автоматически, так как это может привести к утрате данных.Language compilers do not perform this conversion automatically because it can involve data loss. Вместо этого они выполняют преобразование только в том случае, если используется оператор приведения (в C#) или функция преобразования (например, CType или CInt в Visual Basic).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. В противном случае они выводят ошибку компилятора.Otherwise, they display a compiler error.

Так как эта операция определяет понижающие преобразования, во время выполнения может возникнуть исключение, OverflowException Если значение выходит BigInteger за пределы диапазона 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. В итоговом значении нет потерь точности, Int32 Если преобразование выполнено успешно.There is no loss of precision in the resulting Int32 value if the conversion is successful.