BigInteger.Explicit BigInteger.Explicit BigInteger.Explicit BigInteger.Explicit Operator

정의

오버로드

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Decimal 개체를 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Double 값을 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

BigInteger 개체를 부호 없는 바이트 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

BigInteger 개체를 Decimal 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

BigInteger 개체를 Double 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

BigInteger 개체를 부호 있는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

BigInteger 개체를 부호 있는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

BigInteger 개체를 부호 있는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

BigInteger 개체를 부호 있는 8비트 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int16입니다.The compliant alternative is Int16.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

BigInteger 개체를 단정밀도 부동 소수점 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

BigInteger 개체를 부호 없는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int32입니다.The compliant alternative is Int32.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

BigInteger 개체를 부호 없는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int64입니다.The compliant alternative is Int64.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

BigInteger 개체를 부호 없는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Double입니다.The compliant alternative is Double.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Single 값을 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Single value to a BigInteger value.

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Decimal 개체를 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

매개 변수

value
Decimal Decimal Decimal Decimal

BigInteger로 변환할 값입니다.The value to convert to a 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. 때문에 변환 DecimalBigInteger 잘라내기 소수 부분이 포함 될 수 있습니다 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).

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Double 값을 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

매개 변수

value
Double Double Double Double

BigInteger로 변환할 값입니다.The value to convert to a 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. 때문에 변환 DoubleBigInteger 잘라내기 소수 부분이 포함 될 수 있습니다 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).

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

BigInteger 개체를 부호 없는 바이트 값으로 변환하는 명시적 변환을 정의합니다.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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

Byte로 변환할 값입니다.The value to convert to a Byte.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerByte 값입니다.The following example illustrates the conversion of BigInteger to Byte values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

BigInteger 개체를 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

Decimal로 변환할 값입니다.The value to convert to a Decimal.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerDecimal 값입니다.The following example illustrates the conversion of BigInteger to Decimal values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

BigInteger 개체를 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

Double로 변환할 값입니다.The value to convert to a Double.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예제

다음 예제에서는 변환을 BigIntegerDouble 값입니다.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. Throw 하지 않는 경우 변환이 실패 한 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.

변환을 BigIntegerDouble 정밀도의 손실 될 수 있습니다.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 e 291 증가, 같음에 대 한 두 변수는 테스트를 변수입니다.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      

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

BigInteger 개체를 부호 있는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 있는 16비트 정수로 변환할 값입니다.The value to convert to a 16-bit signed integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerInt16 값입니다.The following example illustrates the conversion of BigInteger to Int16 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

BigInteger 개체를 부호 있는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 있는 32비트 정수로 변환할 값입니다.The value to convert to a 32-bit signed integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerInt32 값입니다.The following example illustrates the conversion of BigInteger to Int32 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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. 결과의 전체 자릿수 손실 되지 않습니다 Int16 변환이 성공 하는 경우 값입니다.There is no loss of precision in the resulting Int16 value if the conversion is successful.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

BigInteger 개체를 부호 있는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 있는 64비트 정수로 변환할 값입니다.The value to convert to a 64-bit signed integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerInt64 값입니다.The following example illustrates the conversion of BigInteger to Int64 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

중요

이 API는 CLS 규격이 아닙니다.

CLS 대체 규격
System.Int16

BigInteger 개체를 부호 있는 8비트 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 있는 8비트 값으로 변환할 값입니다.The value to convert to a signed 8-bit value.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerSByte 값입니다.The following example illustrates the conversion of BigInteger to SByte values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

BigInteger 개체를 단정밀도 부동 소수점 값으로 변환하는 명시적 변환을 정의합니다.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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

단정밀도 부동 소수점 값으로 변환할 값입니다.The value to convert to a single-precision floating-point value.

반환

value 매개 변수의 가능한 가장 가까운 표현을 포함하는 개체입니다.An object that contains the closest possible representation of the value parameter.

예제

다음 예제에서는 변환을 BigIntegerSingle 값입니다.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. Throw 하지 않는 경우 변환이 실패 한 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.

변환을 BigIntegerSingle 정밀도의 손실 될 수 있습니다.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 e 291 증가, 같음에 대 한 두 변수는 테스트를 변수입니다.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

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

중요

이 API는 CLS 규격이 아닙니다.

CLS 대체 규격
System.Int32

BigInteger 개체를 부호 없는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 없는 16비트 정수로 변환할 값입니다.The value to convert to an unsigned 16-bit integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerUInt16 값입니다.The following example illustrates the conversion of BigInteger to UInt16 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

중요

이 API는 CLS 규격이 아닙니다.

CLS 대체 규격
System.Int64

BigInteger 개체를 부호 없는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 없는 32비트 정수로 변환할 값입니다.The value to convert to an unsigned 32-bit integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerUInt32 값입니다.The following example illustrates the conversion of BigInteger to UInt32 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

중요

이 API는 CLS 규격이 아닙니다.

CLS 대체 규격
System.Double

BigInteger 개체를 부호 없는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 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

매개 변수

value
BigInteger BigInteger BigInteger BigInteger

부호 없는 64비트 정수로 변환할 값입니다.The value to convert to an unsigned 64-bit integer.

반환

value 매개 변수의 값이 들어 있는 개체입니다.An object that contains the value of the value parameter.

예외

valueMinValue보다 작거나 MaxValue보다 큽니다.value is less than MinValue or is greater than MaxValue.

예제

다음 예제에서는 변환을 BigIntegerUInt64 값입니다.The following example illustrates the conversion of BigInteger to UInt64 values. 또한 처리는 OverflowException 때문에 throw 되는 합니다 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.

Throw 할 수 있으므로이 작업은 축소 변환을 정의 합니다는 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.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Single 값을 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

매개 변수

value
Single Single Single Single

BigInteger로 변환할 값입니다.The value to convert to a 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. 때문에 변환 SingleBigInteger 잘라내기 소수 부분이 포함 될 수 있습니다 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).

적용 대상