Decimal.Explicit Оператор
Определение
Перегрузки
| Explicit(Single to Decimal) |
Определяет явное преобразование числа с плавающей запятой одинарной точности в Decimal.Defines an explicit conversion of a single-precision floating-point number to a Decimal. |
| Explicit(Double to Decimal) |
Определяет явное преобразование числа с плавающей запятой двойной точности в Decimal.Defines an explicit conversion of a double-precision floating-point number to a Decimal. |
| Explicit(Decimal to UInt32) |
Определяет явное преобразование Decimal в 32-разрядное целое число без знака.Defines an explicit conversion of a Decimal to a 32-bit unsigned integer. Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. |
| Explicit(Decimal to UInt16) |
Определяет явное преобразование Decimalв 16-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to a 16-bit unsigned integer. Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. |
| Explicit(Decimal to Single) |
Определяет явное преобразование Decimal в число с плавающей запятой одинарной точности.Defines an explicit conversion of a Decimal to a single-precision floating-point number. |
| Explicit(Decimal to SByte) |
Определяет явное преобразование Decimal в 8-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to an 8-bit signed integer. Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. |
| Explicit(Decimal to UInt64) |
Определяет явное преобразование Decimal в 64-разрядное целое число без знака.Defines an explicit conversion of a Decimal to a 64-bit unsigned integer. Этот интерфейс API CLS-несовместим.This API is not CLS-compliant. |
| Explicit(Decimal to Int32) |
Определяет явное преобразование Decimal в 32-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to a 32-bit signed integer. |
| Explicit(Decimal to Int16) |
Определяет явное преобразование Decimal в 16-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to a 16-bit signed integer. |
| Explicit(Decimal to Double) |
Определяет явное преобразование Decimal в число с плавающей запятой двойной точности.Defines an explicit conversion of a Decimal to a double-precision floating-point number. |
| Explicit(Decimal to Char) |
Определяет явное преобразование объекта Decimal в символ Юникод.Defines an explicit conversion of a Decimal to a Unicode character. |
| Explicit(Decimal to Byte) |
Определяет явное преобразование Decimalв 8-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to an 8-bit unsigned integer. |
| Explicit(Decimal to Int64) |
Определяет явное преобразование Decimal в 64-разрядное целое число со знаком.Defines an explicit conversion of a Decimal to a 64-bit signed integer. |
Explicit(Single to Decimal)
public:
static explicit operator System::Decimal(float value);public static explicit operator decimal (float value);static member op_Explicit : single -> decimalPublic Shared Narrowing Operator CType (value As Single) As DecimalПараметры
- value
- Single
Число с плавающей запятой одиночной точности, подлежащее преобразованию.The single-precision floating-point number to convert.
Возвращаемое значение
Преобразованное число одиночной точности с плавающей запятой.The converted single-precision floating point number.
Исключения
value больше MaxValue или меньше MinValue.value is greater than MaxValue or less than MinValue.
- или --or-
Значение параметра value равно NaN, PositiveInfinity или NegativeInfinity.value is NaN, PositiveInfinity, or NegativeInfinity.
Примеры
В следующем примере значения преобразуются Single в Decimal числа с Single помощью Decimal оператора to Conversion.The following example converts Single values to Decimal numbers by using the Single to Decimal conversion operator. Для этого преобразования требуется оператор op_Explicit в Visual Basic.This conversion requires the op_Explicit operator in Visual Basic.
// Example of the explicit conversion from float to Decimal.
using namespace System;
#define formatter "{0,16:E7}{1,33}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the float argument; catch exceptions that are thrown.
void DecimalFromSingle( float argument )
{
Object^ decValue;
// Convert the float argument to a Decimal value.
try
{
decValue = (Decimal)argument;
}
catch ( Exception^ ex )
{
decValue = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, decValue );
}
int main()
{
Console::WriteLine( "This example of the explicit conversion from float "
"to Decimal \ngenerates the following output.\n" );
Console::WriteLine( formatter, "float argument", "Decimal value" );
Console::WriteLine( formatter, "--------------", "-------------" );
// Convert float values and display the results.
DecimalFromSingle( 1.2345E-30F );
DecimalFromSingle( 1.2345E-26F );
DecimalFromSingle( 1.23456E-22F );
DecimalFromSingle( 1.23456E-12F );
DecimalFromSingle( 1.234567F );
DecimalFromSingle( 1.234567E+12F );
DecimalFromSingle( 1.2345678E+28F );
DecimalFromSingle( 1.2345678E+30F );
}
/*
This example of the explicit conversion from float to Decimal
generates the following output.
float argument Decimal value
-------------- -------------
1.2345000E-030 0
1.2345000E-026 0.0000000000000000000000000123
1.2345600E-022 0.000000000000000000000123456
1.2345600E-012 0.00000000000123456
1.2345671E+000 1.234567
1.2345670E+012 1234567000000
1.2345678E+028 12345680000000000000000000000
1.2345678E+030 OverflowException
*/
// Example of the explicit conversion from float to decimal.
using System;
class DecimalFromSingleDemo
{
const string formatter = "{0,16:E7}{1,33}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the float argument; catch exceptions that are thrown.
public static void DecimalFromSingle( float argument )
{
object decValue;
// Convert the float argument to a decimal value.
try
{
decValue = (decimal)argument;
}
catch( Exception ex )
{
decValue = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument, decValue );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversion from float " +
"to decimal \ngenerates the following output.\n" );
Console.WriteLine( formatter, "float argument",
"decimal value" );
Console.WriteLine( formatter, "--------------",
"-------------" );
// Convert float values and display the results.
DecimalFromSingle( 1.2345E-30F );
DecimalFromSingle( 1.2345E-26F );
DecimalFromSingle( 1.23456E-22F );
DecimalFromSingle( 1.23456E-12F );
DecimalFromSingle( 1.234567F );
DecimalFromSingle( 1.234567E+12F );
DecimalFromSingle( 1.2345678E+28F );
DecimalFromSingle( 1.2345678E+30F );
}
}
/*
This example of the explicit conversion from float to decimal
generates the following output.
float argument decimal value
-------------- -------------
1.2345000E-030 0
1.2345000E-026 0.0000000000000000000000000123
1.2345600E-022 0.000000000000000000000123456
1.2345600E-012 0.00000000000123456
1.2345671E+000 1.234567
1.2345670E+012 1234567000000
1.2345678E+028 12345680000000000000000000000
1.2345678E+030 OverflowException
*/
' Example of the explicit conversion from Single to Decimal.
Module DecimalFromSingleDemo
Const formatter As String = "{0,16:E7}{1,33}"
' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( ex As Exception ) As String
Dim exceptionType As String = ex.GetType( ).ToString( )
Return exceptionType.Substring( _
exceptionType.LastIndexOf( "."c ) + 1 )
End Function
' Convert the Single argument; catch exceptions that are thrown.
Sub DecimalFromSingle( argument As Single )
Dim decValue As Object
' Convert the Single argument to a Decimal value.
Try
decValue = Decimal.op_Explicit( argument )
Catch ex As Exception
decValue = GetExceptionType( ex )
End Try
' Display the Decimal.
Console.WriteLine( formatter, argument, decValue )
End Sub
Sub Main( )
Console.WriteLine( _
"This example of the explicit conversion from Single " & _
"to Decimal " & vbCrLf & "generates the following " & _
"output." & vbCrLf )
Console.WriteLine( formatter, "Single argument", _
"Decimal value" )
Console.WriteLine( formatter, "---------------", _
"-------------" )
' Convert Single values and display the results.
DecimalFromSingle( 1.2345E-30 )
DecimalFromSingle( 1.2345E-26 )
DecimalFromSingle( 1.23456E-22 )
DecimalFromSingle( 1.23456E-12 )
DecimalFromSingle( 1.234567 )
DecimalFromSingle( 1.234567E+12 )
DecimalFromSingle( 1.2345678E+28 )
DecimalFromSingle( 1.2345678E+30 )
End Sub
End Module
' This example of the explicit conversion from Single to Decimal
' generates the following output.
'
' Single argument Decimal value
' --------------- -------------
' 1.2345000E-030 0
' 1.2345000E-026 0.0000000000000000000000000123
' 1.2345600E-022 0.000000000000000000000123456
' 1.2345600E-012 0.00000000000123456
' 1.2345671E+000 1.234567
' 1.2345670E+012 1234567000000
' 1.2345678E+028 12345680000000000000000000000
' 1.2345678E+030 OverflowException
См. также раздел
Применяется к
Explicit(Double to Decimal)
public:
static explicit operator System::Decimal(double value);public static explicit operator decimal (double value);static member op_Explicit : double -> decimalPublic Shared Narrowing Operator CType (value As Double) As DecimalПараметры
- value
- Double
Число с плавающей запятой двойной точности, подлежащее преобразованию.The double-precision floating-point number to convert.
Возвращаемое значение
Преобразованное число двойной точности с плавающей запятой.The converted double-precision floating point number.
Исключения
value больше MaxValue или меньше MinValue.value is greater than MaxValue or less than MinValue.
- или --or-
value имеет значение NaN, PositiveInfinity или NegativeInfinity.value is NaN, PositiveInfinity, or NegativeInfinity.
Примеры
В следующем примере значения преобразуются Double в Decimal числа с Double помощью Decimal оператора to Conversion.The following example converts Double values to Decimal numbers by using the Double to Decimal conversion operator. Для этого преобразования требуется оператор op_Explicit в Visual Basic.This conversion requires the op_Explicit operator in Visual Basic.
// Example of the explicit conversion from double to Decimal.
using namespace System;
#define formatter "{0,25:E16}{1,33}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the double argument; catch exceptions that are thrown.
void DecimalFromDouble( double argument )
{
Object^ decValue;
// Convert the double argument to a Decimal value.
try
{
decValue = (Decimal)argument;
}
catch ( Exception^ ex )
{
decValue = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, decValue );
}
int main()
{
Console::WriteLine( "This example of the explicit conversion from double "
"to Decimal \ngenerates the following output.\n" );
Console::WriteLine( formatter, "double argument", "Decimal value" );
Console::WriteLine( formatter, "---------------", "-------------" );
// Convert double values and display the results.
DecimalFromDouble( 1.234567890123E-30 );
DecimalFromDouble( 1.2345678901234E-25 );
DecimalFromDouble( 1.23456789012345E-20 );
DecimalFromDouble( 1.234567890123456E-10 );
DecimalFromDouble( 1.2345678901234567 );
DecimalFromDouble( 1.23456789012345678E+12 );
DecimalFromDouble( 1.234567890123456789E+28 );
DecimalFromDouble( 1.234567890123456789E+30 );
}
/*
This example of the explicit conversion from double to Decimal
generates the following output.
double argument Decimal value
--------------- -------------
1.2345678901230000E-030 0
1.2345678901233999E-025 0.0000000000000000000000001235
1.2345678901234499E-020 0.0000000000000000000123456789
1.2345678901234560E-010 0.000000000123456789012346
1.2345678901234567E+000 1.23456789012346
1.2345678901234568E+012 1234567890123.46
1.2345678901234568E+028 12345678901234600000000000000
1.2345678901234569E+030 OverflowException
*/
// Example of the explicit conversion from double to decimal.
using System;
class DecimalFromDoubleDemo
{
const string formatter = "{0,25:E16}{1,33}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the double argument; catch exceptions that are thrown.
public static void DecimalFromDouble( double argument )
{
object decValue;
// Convert the double argument to a decimal value.
try
{
decValue = (decimal)argument;
}
catch( Exception ex )
{
decValue = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument, decValue );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversion from double " +
"to decimal \ngenerates the following output.\n" );
Console.WriteLine( formatter, "double argument",
"decimal value" );
Console.WriteLine( formatter, "---------------",
"-------------" );
// Convert double values and display the results.
DecimalFromDouble( 1.234567890123E-30 );
DecimalFromDouble( 1.2345678901234E-25 );
DecimalFromDouble( 1.23456789012345E-20 );
DecimalFromDouble( 1.234567890123456E-10 );
DecimalFromDouble( 1.2345678901234567 );
DecimalFromDouble( 1.23456789012345678E+12 );
DecimalFromDouble( 1.234567890123456789E+28 );
DecimalFromDouble( 1.234567890123456789E+30 );
}
}
/*
This example of the explicit conversion from double to decimal
generates the following output.
double argument decimal value
--------------- -------------
1.2345678901230000E-030 0
1.2345678901233999E-025 0.0000000000000000000000001235
1.2345678901234499E-020 0.0000000000000000000123456789
1.2345678901234560E-010 0.000000000123456789012346
1.2345678901234567E+000 1.23456789012346
1.2345678901234568E+012 1234567890123.46
1.2345678901234568E+028 12345678901234600000000000000
1.2345678901234569E+030 OverflowException
*/
' Example of the explicit conversion from Double to Decimal.
Module DecimalFromDoubleDemo
Const formatter As String = "{0,25:E16}{1,33}"
' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( ex As Exception ) As String
Dim exceptionType As String = ex.GetType( ).ToString( )
Return exceptionType.Substring( _
exceptionType.LastIndexOf( "."c ) + 1 )
End Function
' Convert the Double argument; catch exceptions that are thrown.
Sub DecimalFromDouble( argument As Double )
Dim decValue As Object
' Convert the Double argument to a Decimal value.
Try
decValue = Decimal.op_Explicit( argument )
Catch ex As Exception
decValue = GetExceptionType( ex )
End Try
' Display the Decimal.
Console.WriteLine( formatter, argument, decValue )
End Sub
Sub Main( )
Console.WriteLine( _
"This example of the explicit conversion from Double " & _
"to Decimal " & vbCrLf & "generates the following " & _
"output." & vbCrLf )
Console.WriteLine( formatter, "Double argument", _
"Decimal value" )
Console.WriteLine( formatter, "---------------", _
"-------------" )
' Convert Double values and display the results.
DecimalFromDouble( 1.234567890123E-30 )
DecimalFromDouble( 1.2345678901234E-25 )
DecimalFromDouble( 1.23456789012345E-20 )
DecimalFromDouble( 1.234567890123456E-10 )
DecimalFromDouble( 1.2345678901234567 )
DecimalFromDouble( 1.23456789012345678E+12 )
DecimalFromDouble( 1.234567890123456789E+28 )
DecimalFromDouble( 1.234567890123456789E+30 )
End Sub
End Module
' This example of the explicit conversion from Double to Decimal
' generates the following output.
'
' Double argument Decimal value
' --------------- -------------
' 1.2345678901230000E-030 0
' 1.2345678901233999E-025 0.0000000000000000000000001235
' 1.2345678901234499E-020 0.0000000000000000000123456789
' 1.2345678901234560E-010 0.000000000123456789012346
' 1.2345678901234567E+000 1.23456789012346
' 1.2345678901234568E+012 1234567890123.46
' 1.2345678901234568E+028 12345678901234600000000000000
' 1.2345678901234569E+030 OverflowException
См. также раздел
Применяется к
Explicit(Decimal to UInt32)
Важно!
Этот API несовместим с CLS.
- Альтернативный вариант, совместимый с CLS
- System.Decimal.ToInt64(Decimal)
public:
static explicit operator System::UInt32(System::Decimal value);[System.CLSCompliant(false)]
public static explicit operator uint (decimal value);[<System.CLSCompliant(false)>]
static member op_Explicit : decimal -> uint32Public Shared Narrowing Operator CType (value As Decimal) As UIntegerПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
32-разрядное целое число без знака, которое представляет преобразованное значение типа Decimal.A 32-bit unsigned integer that represents the converted Decimal.
- Атрибуты
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в UInt32 значения с помощью Decimal оператора Explicit к UInt32 преобразованию.The following example converts Decimal numbers to UInt32 values by using the explicit Decimal to UInt32 conversion operator.
// Example of the explicit conversions from Decimal to int and
// Decimal to unsigned int.
using namespace System;
#define formatter "{0,17}{1,19}{2,19}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int32( Decimal argument )
{
Object^ Int32Value;
Object^ UInt32Value;
// Convert the argument to an int value.
try
{
Int32Value = (int)argument;
}
catch ( Exception^ ex )
{
Int32Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned int value.
try
{
UInt32Value = (unsigned int)argument;
}
catch ( Exception^ ex )
{
UInt32Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int32Value, UInt32Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"int \nand Decimal to unsigned int generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "int", "unsigned int" );
Console::WriteLine( formatter, "----------------", "---", "------------" );
// Convert Decimal values and display the results.
DecimalToU_Int32( Decimal::Parse( "123" ) );
DecimalToU_Int32( Decimal(123000,0,0,false,3) );
DecimalToU_Int32( Decimal::Parse( "123.999" ) );
DecimalToU_Int32( Decimal::Parse( "4294967295.999" ) );
DecimalToU_Int32( Decimal::Parse( "4294967296" ) );
DecimalToU_Int32( Decimal::Parse( "2147483647.999" ) );
DecimalToU_Int32( Decimal::Parse( "2147483648" ) );
DecimalToU_Int32( Decimal::Parse( "-0.999" ) );
DecimalToU_Int32( Decimal::Parse( "-1" ) );
DecimalToU_Int32( Decimal::Parse( "-2147483648.999" ) );
DecimalToU_Int32( Decimal::Parse( "-2147483649" ) );
}
/*
This example of the explicit conversions from Decimal to int
and Decimal to unsigned int generates the following output.
It displays several converted Decimal values.
Decimal argument int unsigned int
---------------- --- ------------
123 123 123
123.000 123 123
123.999 123 123
4294967295.999 OverflowException 4294967295
4294967296 OverflowException OverflowException
2147483647.999 2147483647 2147483647
2147483648 OverflowException 2147483648
-0.999 0 0
-1 -1 OverflowException
-2147483648.999 -2147483648 OverflowException
-2147483649 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to int and
// decimal to uint.
using System;
class DecimalToU_Int32Demo
{
const string formatter = "{0,17}{1,19}{2,19}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int32( decimal argument )
{
object Int32Value;
object UInt32Value;
// Convert the argument to an int value.
try
{
Int32Value = (int)argument;
}
catch( Exception ex )
{
Int32Value = GetExceptionType( ex );
}
// Convert the argument to a uint value.
try
{
UInt32Value = (uint)argument;
}
catch( Exception ex )
{
UInt32Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int32Value, UInt32Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to int \nand decimal to uint generates the following " +
"output. It displays \nseveral converted decimal " +
"values.\n" );
Console.WriteLine( formatter, "decimal argument",
"int/exception", "uint/exception" );
Console.WriteLine( formatter, "----------------",
"-------------", "--------------" );
// Convert decimal values and display the results.
DecimalToU_Int32( 123M );
DecimalToU_Int32( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int32( 123.999M );
DecimalToU_Int32( 4294967295.999M );
DecimalToU_Int32( 4294967296M );
DecimalToU_Int32( 2147483647.999M );
DecimalToU_Int32( 2147483648M );
DecimalToU_Int32( - 0.999M );
DecimalToU_Int32( - 1M );
DecimalToU_Int32( - 2147483648.999M );
DecimalToU_Int32( - 2147483649M );
}
}
/*
This example of the explicit conversions from decimal to int
and decimal to uint generates the following output. It displays
several converted decimal values.
decimal argument int/exception uint/exception
---------------- ------------- --------------
123 123 123
123.000 123 123
123.999 123 123
4294967295.999 OverflowException 4294967295
4294967296 OverflowException OverflowException
2147483647.999 2147483647 2147483647
2147483648 OverflowException 2147483648
-0.999 0 0
-1 -1 OverflowException
-2147483648.999 -2147483648 OverflowException
-2147483649 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Integer and
' Decimal to UInteger.
Module DecimalToU_Int32Demo
Const formatter As String = "{0,17}{1,19}{2,19}"
' Convert the decimal argument catch exceptions that are thrown.
Public Sub DecimalToU_Int32(argument As Decimal)
Dim Int32Value As Object
Dim UInt32Value As Object
' Convert the argument to an int value.
Try
Int32Value = CInt(argument)
Catch ex As Exception
Int32Value = ex.GetType().Name
End Try
' Convert the argument to a uint value.
Try
UInt32Value = CUInt(argument)
Catch ex As Exception
UInt32Value = ex.GetType().Name
End Try
Console.WriteLine(formatter, argument, _
Int32Value, UInt32Value)
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal Argument", _
"Integer/Exception", "UInteger/Exception" )
Console.WriteLine( formatter, "----------------", _
"-------------", "--------------" )
' Convert decimal values and display the results.
DecimalToU_Int32( 123d)
DecimalToU_Int32(New Decimal(123000, 0, 0, False, 3))
DecimalToU_Int32(123.999d)
DecimalToU_Int32(4294967295.999d)
DecimalToU_Int32(4294967296d)
DecimalToU_Int32(2147483647.999d)
DecimalToU_Int32(2147483648d)
DecimalToU_Int32(-0.999d)
DecimalToU_Int32(-1d)
DecimalToU_Int32(-2147483648.999d)
DecimalToU_Int32(-2147483649d)
End Sub
End Module
' The example displays the following output to the console:
' Decimal Argument Integer/Exception UInteger/Exception
' ---------------- ------------- --------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 4294967295.999 OverflowException OverflowException
' 4294967296 OverflowException OverflowException
' 2147483647.999 OverflowException 2147483648
' 2147483648 OverflowException 2147483648
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -2147483648.999 OverflowException OverflowException
' -2147483649 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в UInt32 .This operator supports the explicit conversion of a Decimal to a UInt32. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в UInt32 значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a UInt32 value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToUInt32(Decimal) Convert.ToUInt32(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToUInt32(Decimal) or the Convert.ToUInt32(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to UInt16)
Важно!
Этот API несовместим с CLS.
public:
static explicit operator System::UInt16(System::Decimal value);[System.CLSCompliant(false)]
public static explicit operator ushort (decimal value);[<System.CLSCompliant(false)>]
static member op_Explicit : decimal -> uint16Public Shared Narrowing Operator CType (value As Decimal) As UShortПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
16-разрядное целое число без знака, которое представляет преобразованное значение типа Decimal.A 16-bit unsigned integer that represents the converted Decimal.
- Атрибуты
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в UInt16 значения с помощью Decimal оператора Explicit к UInt16 преобразованию.The following example converts Decimal numbers to UInt16 values by using the explicit Decimal to UInt16 conversion operator.
// Example of the explicit conversions from Decimal to short and
// Decimal to unsigned short.
using namespace System;
#define formatter "{0,16}{1,19}{2,19}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int16( Decimal argument )
{
Object^ Int16Value;
Object^ UInt16Value;
// Convert the argument to a short value.
try
{
Int16Value = (short)argument;
}
catch ( Exception^ ex )
{
Int16Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned short value.
try
{
UInt16Value = (unsigned short)argument;
}
catch ( Exception^ ex )
{
UInt16Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int16Value, UInt16Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"short \nand Decimal to unsigned short generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "short", "unsigned short" );
Console::WriteLine( formatter, "----------------", "-----", "--------------" );
// Convert Decimal values and display the results.
DecimalToU_Int16( Decimal::Parse( "123" ) );
DecimalToU_Int16( Decimal(123000,0,0,false,3) );
DecimalToU_Int16( Decimal::Parse( "123.999" ) );
DecimalToU_Int16( Decimal::Parse( "65535.999" ) );
DecimalToU_Int16( Decimal::Parse( "65536" ) );
DecimalToU_Int16( Decimal::Parse( "32767.999" ) );
DecimalToU_Int16( Decimal::Parse( "32768" ) );
DecimalToU_Int16( Decimal::Parse( "-0.999" ) );
DecimalToU_Int16( Decimal::Parse( "-1" ) );
DecimalToU_Int16( Decimal::Parse( "-32768.999" ) );
DecimalToU_Int16( Decimal::Parse( "-32769" ) );
}
/*
This example of the explicit conversions from Decimal to short
and Decimal to unsigned short generates the following output.
It displays several converted Decimal values.
Decimal argument short unsigned short
---------------- ----- --------------
123 123 123
123.000 123 123
123.999 123 123
65535.999 OverflowException 65535
65536 OverflowException OverflowException
32767.999 32767 32767
32768 OverflowException 32768
-0.999 0 0
-1 -1 OverflowException
-32768.999 -32768 OverflowException
-32769 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to short and
// decimal to ushort.
using System;
class DecimalToU_Int16Demo
{
const string formatter = "{0,16}{1,19}{2,19}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int16( decimal argument )
{
object Int16Value;
object UInt16Value;
// Convert the argument to a short value.
try
{
Int16Value = (short)argument;
}
catch( Exception ex )
{
Int16Value = GetExceptionType( ex );
}
// Convert the argument to a ushort value.
try
{
UInt16Value = (ushort)argument;
}
catch( Exception ex )
{
UInt16Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int16Value, UInt16Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to short \nand decimal to ushort generates the " +
"following output. It displays \nseveral converted " +
"decimal values.\n" );
Console.WriteLine( formatter, "decimal argument",
"short/exception", "ushort/exception" );
Console.WriteLine( formatter, "----------------",
"---------------", "----------------" );
// Convert decimal values and display the results.
DecimalToU_Int16( 123M );
DecimalToU_Int16( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int16( 123.999M );
DecimalToU_Int16( 65535.999M );
DecimalToU_Int16( 65536M );
DecimalToU_Int16( 32767.999M );
DecimalToU_Int16( 32768M );
DecimalToU_Int16( - 0.999M );
DecimalToU_Int16( - 1M );
DecimalToU_Int16( - 32768.999M );
DecimalToU_Int16( - 32769M );
}
}
/*
This example of the explicit conversions from decimal to short
and decimal to ushort generates the following output. It displays
several converted decimal values.
decimal argument short/exception ushort/exception
---------------- --------------- ----------------
123 123 123
123.000 123 123
123.999 123 123
65535.999 OverflowException 65535
65536 OverflowException OverflowException
32767.999 32767 32767
32768 OverflowException 32768
-0.999 0 0
-1 -1 OverflowException
-32768.999 -32768 OverflowException
-32769 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Short and
' Decimal to UShort.
Module DecimalToU_Int16Demo
Const formatter As String = "{0,16}{1,19}{2,19}"
' Convert the decimal argument and catch exceptions that are thrown.
Public Sub DecimalToU_Int16(argument As Decimal)
Dim Int16Value As Object
Dim UInt16Value As Object
' Convert the argument to a Short value.
Try
Int16Value = CShort(argument)
Catch ex As Exception
Int16Value = ex.GetType().Name
End Try
' Convert the argument to a UShort value.
Try
UInt16Value = CUShort(argument)
Catch ex As Exception
UInt16Value = ex.GetType().Name
End Try
Console.WriteLine( formatter, argument, _
Int16Value, UInt16Value )
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal argument", _
"Short/Exception", "UShort/Exception" )
Console.WriteLine( formatter, "----------------", _
"---------------", "----------------" )
' Convert decimal values and display the results.
DecimalToU_Int16(123d)
DecimalToU_Int16(New Decimal( 123000, 0, 0, False, 3 ))
DecimalToU_Int16(123.999d)
DecimalToU_Int16(65535.999d)
DecimalToU_Int16(65536d)
DecimalToU_Int16(32767.999d)
DecimalToU_Int16(32768d)
DecimalToU_Int16(-0.999d)
DecimalToU_Int16(-1d)
DecimalToU_Int16(-32768.999d)
DecimalToU_Int16(-32769d)
End Sub
End Module
' This example displays the following output to the console:
' Decimal argument Short/Exception UShort/Exception
' ---------------- --------------- ----------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 65535.999 OverflowException OverflowException
' 65536 OverflowException OverflowException
' 32767.999 OverflowException 32768
' 32768 OverflowException 32768
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -32768.999 OverflowException OverflowException
' -32769 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в UInt16 .This operator supports the explicit conversion of a Decimal to a UInt16. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в UInt16 значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a UInt16 value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToUInt16(Decimal) Convert.ToUInt16(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToUInt16(Decimal) or the Convert.ToUInt16(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Single)
public:
static explicit operator float(System::Decimal value);public static explicit operator float (decimal value);static member op_Explicit : decimal -> singlePublic Shared Narrowing Operator CType (value As Decimal) As SingleПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
Значение одиночной точности с плавающей запятой, которое представляет преобразованное значение Decimal.A single-precision floating-point number that represents the converted Decimal.
Примеры
В следующем примере числа преобразуются Decimal в Single значения с помощью Decimal оператора Explicit к Single преобразованию.The following example converts Decimal numbers to Single values by using the explicit Decimal to Single conversion operator.
using namespace System;
void main()
{
// Define an array of Decimal values.
array<Decimal>^ values = { Decimal::Parse("0.0000000000000000000000000001"),
Decimal::Parse("0.0000000000123456789123456789"),
Decimal::Parse("123"),
Decimal(123000000, 0, 0, false, 6),
Decimal::Parse("123456789.123456789"),
Decimal::Parse("123456789123456789123456789"),
Decimal::MinValue, Decimal::MaxValue };
// Convert each value to a double.
for each (Decimal value in values) {
float dblValue = (float) value;
Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType()->Name, dblValue,
dblValue.GetType()->Name);
}
}
// The example displays the following output:
// 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Single)
// 0.0000000000123456789123456789 (Decimal) --> 1.234568E-11 (Single)
// 123 (Decimal) --> 123 (Single)
// 123.000000 (Decimal) --> 123 (Single)
// 123456789.123456789 (Decimal) --> 1.234568E+08 (Single)
// 123456789123456789123456789 (Decimal) --> 1.234568E+26 (Single)
// -79228162514264337593543950335 (Decimal) --> -7.922816E+28 (Single)
// 79228162514264337593543950335 (Decimal) --> 7.922816E+28 (Single)
using System;
class Example
{
public static void Main( )
{
// Define an array of decimal values.
decimal[] values = { 0.0000000000000000000000000001M,
0.0000000000123456789123456789M,
123M, new decimal(123000000, 0, 0, false, 6),
123456789.123456789M,
123456789123456789123456789M,
decimal.MinValue, decimal.MaxValue };
// Convert each value to a double.
foreach (var value in values) {
float dblValue = (float) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, dblValue,
dblValue.GetType().Name);
}
}
}
// The example displays the following output:
// 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Single)
// 0.0000000000123456789123456789 (Decimal) --> 1.234568E-11 (Single)
// 123 (Decimal) --> 123 (Single)
// 123.000000 (Decimal) --> 123 (Single)
// 123456789.123456789 (Decimal) --> 1.234568E+08 (Single)
// 123456789123456789123456789 (Decimal) --> 1.234568E+26 (Single)
// -79228162514264337593543950335 (Decimal) --> -7.922816E+28 (Single)
// 79228162514264337593543950335 (Decimal) --> 7.922816E+28 (Single)
Module Example
Public Sub Main( )
' Define an array of Decimal values.
Dim values() As Decimal= { 0.0000000000000000000000000001d,
0.0000000000123456789123456789d,
123d,
New Decimal(123000000, 0, 0, False, 6),
123456789.123456789d,
123456789123456789123456789d,
Decimal.MinValue, Decimal.MaxValue }
For Each value In values
Dim dblValue As Single = CSng(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, dblValue,
dblValue.GetType().Name)
Next
End Sub
End Module
' The example displays the following output:
' 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Single)
' 0.0000000000123456789123456789 (Decimal) --> 1.234568E-11 (Single)
' 123 (Decimal) --> 123 (Single)
' 123.000000 (Decimal) --> 123 (Single)
' 123456789.123456789 (Decimal) --> 1.234568E+08 (Single)
' 123456789123456789123456789 (Decimal) --> 1.234568E+26 (Single)
' -79228162514264337593543950335 (Decimal) --> -7.922816E+28 (Single)
' 79228162514264337593543950335 (Decimal) --> 7.922816E+28 (Single)
Комментарии
Эта операция может привести к утрате точности, так как число с плавающей запятой одиночной точности содержит меньше значащих цифр, чем Decimal .This operation can result in a loss of precision, because a single-precision floating-point number has fewer significant digits than a Decimal.
Этот оператор поддерживает явное преобразование типа Decimal в Single .This operator supports the explicit conversion of a Decimal to a Single. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Single значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a Single value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToSingle(Decimal) Convert.ToSingle(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToSingle(Decimal) or the Convert.ToSingle(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to SByte)
Важно!
Этот API несовместим с CLS.
- Альтернативный вариант, совместимый с CLS
- System.Decimal.ToInt16(Decimal)
public:
static explicit operator System::SByte(System::Decimal value);[System.CLSCompliant(false)]
public static explicit operator sbyte (decimal value);[<System.CLSCompliant(false)>]
static member op_Explicit : decimal -> sbytePublic Shared Narrowing Operator CType (value As Decimal) As SByteПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
8-разрядное целое число со знаком, которое представляет преобразованное значение типа Decimal.An 8-bit signed integer that represents the converted Decimal.
- Атрибуты
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в SByte значения с помощью Decimal оператора Explicit к SByte преобразованию.The following example converts Decimal numbers to SByte values by using the explicit Decimal to SByte conversion operator.
using namespace System;
void main()
{
// Define an array of decimal values.
array<Decimal>^ values = { Decimal::Parse("78"),
Decimal(78000,0,0,false,3),
Decimal::Parse("78.999"),
Decimal::Parse("255.999"),
Decimal::Parse("256"),
Decimal::Parse("127.999"),
Decimal::Parse("128"),
Decimal::Parse("-0.999"),
Decimal::Parse("-1"),
Decimal::Parse("-128.999"),
Decimal::Parse("-129") };
for each (Decimal value in values) {
try {
SByte byteValue = (SByte) value;
Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType()->Name, byteValue,
byteValue.GetType()->Name);
}
catch (OverflowException^ e) {
Console::WriteLine("OverflowException: Cannot convert {0}",
value);
}
}
}
// The example displays the following output:
// 78 (Decimal) --> 78 (SByte)
// 78.000 (Decimal) --> 78 (SByte)
// 78.999 (Decimal) --> 78 (SByte)
// OverflowException: Cannot convert 255.999
// OverflowException: Cannot convert 256
// 127.999 (Decimal) --> 127 (SByte)
// OverflowException: Cannot convert 128
// -0.999 (Decimal) --> 0 (SByte)
// -1 (Decimal) --> -1 (SByte)
// -128.999 (Decimal) --> -128 (SByte)
// OverflowException: Cannot convert -129
using System;
class Example
{
public static void Main()
{
// Define an array of decimal values.
decimal[] values = { 78m, new Decimal(78000, 0, 0, false, 3),
78.999m, 255.999m, 256m, 127.999m,
128m, -0.999m, -1m, -128.999m, -129m };
foreach (var value in values) {
try {
SByte byteValue = (SByte) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, byteValue,
byteValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("OverflowException: Cannot convert {0}",
value);
}
}
}
}
// The example displays the following output:
// 78 (Decimal) --> 78 (SByte)
// 78.000 (Decimal) --> 78 (SByte)
// 78.999 (Decimal) --> 78 (SByte)
// OverflowException: Cannot convert 255.999
// OverflowException: Cannot convert 256
// 127.999 (Decimal) --> 127 (SByte)
// OverflowException: Cannot convert 128
// -0.999 (Decimal) --> 0 (SByte)
// -1 (Decimal) --> -1 (SByte)
// -128.999 (Decimal) --> -128 (SByte)
// OverflowException: Cannot convert -129
Option Strict On
Module Example
Public Sub Main()
' Define an array of decimal values.
Dim values() As Decimal = { 78d, New Decimal(78000, 0, 0, False, 3),
78.999d, 255.999d, 256d, 127.999d,
128d, -0.999d, -1d, -128.999d,
-129d }
For Each value In values
Try
Dim byteValue As SByte = CSByte(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, byteValue,
byteValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("OverflowException: Cannot convert {0}",
value)
End Try
Next
End Sub
End Module
' The example displays the following output:
' 78 (Decimal) --> 78 (SByte)
' 78.000 (Decimal) --> 78 (SByte)
' 78.999 (Decimal) --> 79 (SByte)
' OverflowException: Cannot convert 255.999
' OverflowException: Cannot convert 256
' OverflowException: Cannot convert 127.999
' OverflowException: Cannot convert 128
' -0.999 (Decimal) --> -1 (SByte)
' -1 (Decimal) --> -1 (SByte)
' OverflowException: Cannot convert -128.999
' OverflowException: Cannot convert -129
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в SByte .This operator supports the explicit conversion of a Decimal to a SByte. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Byte и в SByte значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a Byte and an SByte value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToSByte(Decimal) метод или Convert.ToSByte(Decimal) метод.To perform a conversion that is independent of language, you can call the Decimal.ToSByte(Decimal) method or the Convert.ToSByte(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to UInt64)
Важно!
Этот API несовместим с CLS.
public:
static explicit operator System::UInt64(System::Decimal value);[System.CLSCompliant(false)]
public static explicit operator ulong (decimal value);[<System.CLSCompliant(false)>]
static member op_Explicit : decimal -> uint64Public Shared Narrowing Operator CType (value As Decimal) As ULongПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
64-разрядное целое число без знака, которое представляет преобразованное значение типа Decimal.A 64-bit unsigned integer that represents the converted Decimal.
- Атрибуты
Исключения
Примеры
В следующем примере числа преобразуются Decimal в UInt64 значения с помощью Decimal оператора Explicit к UInt64 преобразованию.The following example converts Decimal numbers to UInt64 values by using the explicit Decimal to UInt64 conversion operator.
// Example of the explicit conversions from Decimal to __int64 and
// Decimal to unsigned __int64.
using namespace System;
#define formatter "{0,25}{1,22}{2,22}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int64( Decimal argument )
{
Object^ Int64Value;
Object^ UInt64Value;
// Convert the argument to an __int64 value.
try
{
Int64Value = (__int64)argument;
}
catch ( Exception^ ex )
{
Int64Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned __int64 value.
try
{
UInt64Value = (unsigned __int64)argument;
}
catch ( Exception^ ex )
{
UInt64Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int64Value, UInt64Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"__int64 \nand Decimal to unsigned __int64 generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "__int64", "unsigned __int64" );
Console::WriteLine( formatter, "----------------", "-------", "----------------" );
// Convert Decimal values and display the results.
DecimalToU_Int64( Decimal::Parse( "123" ) );
DecimalToU_Int64( Decimal(123000,0,0,false,3) );
DecimalToU_Int64( Decimal::Parse( "123.999" ) );
DecimalToU_Int64( Decimal::Parse( "18446744073709551615.999" ) );
DecimalToU_Int64( Decimal::Parse( "18446744073709551616" ) );
DecimalToU_Int64( Decimal::Parse( "9223372036854775807.999" ) );
DecimalToU_Int64( Decimal::Parse( "9223372036854775808" ) );
DecimalToU_Int64( Decimal::Parse( "-0.999" ) );
DecimalToU_Int64( Decimal::Parse( "-1" ) );
DecimalToU_Int64( Decimal::Parse( "-9223372036854775808.999" ) );
DecimalToU_Int64( Decimal::Parse( "-9223372036854775809" ) );
}
/*
This example of the explicit conversions from Decimal to __int64
and Decimal to unsigned __int64 generates the following output.
It displays several converted Decimal values.
Decimal argument __int64 unsigned __int64
---------------- ------- ----------------
123 123 123
123.000 123 123
123.999 123 123
18446744073709551615.999 OverflowException 18446744073709551615
18446744073709551616 OverflowException OverflowException
9223372036854775807.999 9223372036854775807 9223372036854775807
9223372036854775808 OverflowException 9223372036854775808
-0.999 0 0
-1 -1 OverflowException
-9223372036854775808.999 -9223372036854775808 OverflowException
-9223372036854775809 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to long and
// decimal to ulong.
using System;
class DecimalToU_Int64Demo
{
const string formatter = "{0,25}{1,22}{2,22}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int64( decimal argument )
{
object Int64Value;
object UInt64Value;
// Convert the argument to a long value.
try
{
Int64Value = (long)argument;
}
catch( Exception ex )
{
Int64Value = GetExceptionType( ex );
}
// Convert the argument to a ulong value.
try
{
UInt64Value = (ulong)argument;
}
catch( Exception ex )
{
UInt64Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int64Value, UInt64Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to long \nand decimal to ulong generates the following " +
"output. It displays \nseveral converted decimal " +
"values.\n" );
Console.WriteLine( formatter, "decimal argument",
"long/exception", "ulong/exception" );
Console.WriteLine( formatter, "----------------",
"--------------", "---------------" );
// Convert decimal values and display the results.
DecimalToU_Int64( 123M );
DecimalToU_Int64( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int64( 123.999M );
DecimalToU_Int64( 18446744073709551615.999M );
DecimalToU_Int64( 18446744073709551616M );
DecimalToU_Int64( 9223372036854775807.999M );
DecimalToU_Int64( 9223372036854775808M );
DecimalToU_Int64( - 0.999M );
DecimalToU_Int64( - 1M );
DecimalToU_Int64( - 9223372036854775808.999M );
DecimalToU_Int64( - 9223372036854775809M );
}
}
/*
This example of the explicit conversions from decimal to long
and decimal to ulong generates the following output. It displays
several converted decimal values.
decimal argument long/exception ulong/exception
---------------- -------------- ---------------
123 123 123
123.000 123 123
123.999 123 123
18446744073709551615.999 OverflowException 18446744073709551615
18446744073709551616 OverflowException OverflowException
9223372036854775807.999 9223372036854775807 9223372036854775807
9223372036854775808 OverflowException 9223372036854775808
-0.999 0 0
-1 -1 OverflowException
-9223372036854775808.999 -9223372036854775808 OverflowException
-9223372036854775809 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Long and
' Decimal to ULong.
Module DecimalToU_Int64Demo
Const formatter As String = "{0,25}{1,22}{2,22}"
' Convert the decimal argument catch exceptions that are thrown.
Public Sub DecimalToU_Int64(argument As Decimal)
Dim Int64Value As Object
Dim UInt64Value As Object
' Convert the argument to a long value.
Try
Int64Value = CLng(argument)
Catch ex As Exception
Int64Value = ex.GetType().Name
End Try
' Convert the argument to a ulong value.
Try
UInt64Value = CULng(argument)
Catch ex As Exception
UInt64Value = ex.GetType().Name
End Try
Console.WriteLine(formatter, argument, _
Int64Value, UInt64Value)
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal argument", _
"Long/Exception", "ULong/Exception" )
Console.WriteLine( formatter, "----------------", _
"--------------", "---------------" )
' Convert decimal values and display the results.
DecimalToU_Int64(123d)
DecimalToU_Int64(New Decimal(123000, 0, 0, False, 3))
DecimalToU_Int64(123.999d)
DecimalToU_Int64(18446744073709551615.999d)
DecimalToU_Int64(18446744073709551616d)
DecimalToU_Int64(9223372036854775807.999d)
DecimalToU_Int64(9223372036854775808d)
DecimalToU_Int64(-0.999d)
DecimalToU_Int64(-1d)
DecimalToU_Int64(-9223372036854775808.999d)
DecimalToU_Int64(-9223372036854775809d)
End Sub
End Module
' The example displays the following output to the console:
' Decimal argument Long/Exception ULong/Exception
' ---------------- -------------- ---------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 18446744073709551615.999 OverflowException OverflowException
' 18446744073709551616 OverflowException OverflowException
' 9223372036854775807.999 OverflowException 9223372036854775808
' 9223372036854775808 OverflowException 9223372036854775808
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -9223372036854775808.999 OverflowException OverflowException
' -9223372036854775809 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в UInt64 .This operator supports the explicit conversion of a Decimal to a UInt64. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в UInt64 значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a UInt64 value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToUInt64(Decimal) Convert.ToUInt64(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToUInt64(Decimal) or the Convert.ToUInt64(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Int32)
public:
static explicit operator int(System::Decimal value);public static explicit operator int (decimal value);static member op_Explicit : decimal -> intPublic Shared Narrowing Operator CType (value As Decimal) As IntegerПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
32-разрядное целое число со знаком, которое представляет преобразованное значение Decimal.A 32-bit signed integer that represents the converted Decimal.
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в Int32 значения с помощью Decimal оператора Explicit к Int32 преобразованию.The following example converts Decimal numbers to Int32 values by using the explicit Decimal to Int32 conversion operator.
// Example of the explicit conversions from Decimal to int and
// Decimal to unsigned int.
using namespace System;
#define formatter "{0,17}{1,19}{2,19}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int32( Decimal argument )
{
Object^ Int32Value;
Object^ UInt32Value;
// Convert the argument to an int value.
try
{
Int32Value = (int)argument;
}
catch ( Exception^ ex )
{
Int32Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned int value.
try
{
UInt32Value = (unsigned int)argument;
}
catch ( Exception^ ex )
{
UInt32Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int32Value, UInt32Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"int \nand Decimal to unsigned int generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "int", "unsigned int" );
Console::WriteLine( formatter, "----------------", "---", "------------" );
// Convert Decimal values and display the results.
DecimalToU_Int32( Decimal::Parse( "123" ) );
DecimalToU_Int32( Decimal(123000,0,0,false,3) );
DecimalToU_Int32( Decimal::Parse( "123.999" ) );
DecimalToU_Int32( Decimal::Parse( "4294967295.999" ) );
DecimalToU_Int32( Decimal::Parse( "4294967296" ) );
DecimalToU_Int32( Decimal::Parse( "2147483647.999" ) );
DecimalToU_Int32( Decimal::Parse( "2147483648" ) );
DecimalToU_Int32( Decimal::Parse( "-0.999" ) );
DecimalToU_Int32( Decimal::Parse( "-1" ) );
DecimalToU_Int32( Decimal::Parse( "-2147483648.999" ) );
DecimalToU_Int32( Decimal::Parse( "-2147483649" ) );
}
/*
This example of the explicit conversions from Decimal to int
and Decimal to unsigned int generates the following output.
It displays several converted Decimal values.
Decimal argument int unsigned int
---------------- --- ------------
123 123 123
123.000 123 123
123.999 123 123
4294967295.999 OverflowException 4294967295
4294967296 OverflowException OverflowException
2147483647.999 2147483647 2147483647
2147483648 OverflowException 2147483648
-0.999 0 0
-1 -1 OverflowException
-2147483648.999 -2147483648 OverflowException
-2147483649 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to int and
// decimal to uint.
using System;
class DecimalToU_Int32Demo
{
const string formatter = "{0,17}{1,19}{2,19}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int32( decimal argument )
{
object Int32Value;
object UInt32Value;
// Convert the argument to an int value.
try
{
Int32Value = (int)argument;
}
catch( Exception ex )
{
Int32Value = GetExceptionType( ex );
}
// Convert the argument to a uint value.
try
{
UInt32Value = (uint)argument;
}
catch( Exception ex )
{
UInt32Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int32Value, UInt32Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to int \nand decimal to uint generates the following " +
"output. It displays \nseveral converted decimal " +
"values.\n" );
Console.WriteLine( formatter, "decimal argument",
"int/exception", "uint/exception" );
Console.WriteLine( formatter, "----------------",
"-------------", "--------------" );
// Convert decimal values and display the results.
DecimalToU_Int32( 123M );
DecimalToU_Int32( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int32( 123.999M );
DecimalToU_Int32( 4294967295.999M );
DecimalToU_Int32( 4294967296M );
DecimalToU_Int32( 2147483647.999M );
DecimalToU_Int32( 2147483648M );
DecimalToU_Int32( - 0.999M );
DecimalToU_Int32( - 1M );
DecimalToU_Int32( - 2147483648.999M );
DecimalToU_Int32( - 2147483649M );
}
}
/*
This example of the explicit conversions from decimal to int
and decimal to uint generates the following output. It displays
several converted decimal values.
decimal argument int/exception uint/exception
---------------- ------------- --------------
123 123 123
123.000 123 123
123.999 123 123
4294967295.999 OverflowException 4294967295
4294967296 OverflowException OverflowException
2147483647.999 2147483647 2147483647
2147483648 OverflowException 2147483648
-0.999 0 0
-1 -1 OverflowException
-2147483648.999 -2147483648 OverflowException
-2147483649 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Integer and
' Decimal to UInteger.
Module DecimalToU_Int32Demo
Const formatter As String = "{0,17}{1,19}{2,19}"
' Convert the decimal argument catch exceptions that are thrown.
Public Sub DecimalToU_Int32(argument As Decimal)
Dim Int32Value As Object
Dim UInt32Value As Object
' Convert the argument to an int value.
Try
Int32Value = CInt(argument)
Catch ex As Exception
Int32Value = ex.GetType().Name
End Try
' Convert the argument to a uint value.
Try
UInt32Value = CUInt(argument)
Catch ex As Exception
UInt32Value = ex.GetType().Name
End Try
Console.WriteLine(formatter, argument, _
Int32Value, UInt32Value)
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal Argument", _
"Integer/Exception", "UInteger/Exception" )
Console.WriteLine( formatter, "----------------", _
"-------------", "--------------" )
' Convert decimal values and display the results.
DecimalToU_Int32( 123d)
DecimalToU_Int32(New Decimal(123000, 0, 0, False, 3))
DecimalToU_Int32(123.999d)
DecimalToU_Int32(4294967295.999d)
DecimalToU_Int32(4294967296d)
DecimalToU_Int32(2147483647.999d)
DecimalToU_Int32(2147483648d)
DecimalToU_Int32(-0.999d)
DecimalToU_Int32(-1d)
DecimalToU_Int32(-2147483648.999d)
DecimalToU_Int32(-2147483649d)
End Sub
End Module
' The example displays the following output to the console:
' Decimal Argument Integer/Exception UInteger/Exception
' ---------------- ------------- --------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 4294967295.999 OverflowException OverflowException
' 4294967296 OverflowException OverflowException
' 2147483647.999 OverflowException 2147483648
' 2147483648 OverflowException 2147483648
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -2147483648.999 OverflowException OverflowException
' -2147483649 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в Int32 .This operator supports the explicit conversion of a Decimal to an Int32. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Int32 значение с помощью C#, C++ и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to an Int32 value by using C#, C++, and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToInt32(Decimal) Convert.ToInt32(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToInt32(Decimal) or the Convert.ToInt32(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Int16)
public:
static explicit operator short(System::Decimal value);public static explicit operator short (decimal value);static member op_Explicit : decimal -> int16Public Shared Narrowing Operator CType (value As Decimal) As ShortПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
16-разрядное целое число со знаком, которое представляет преобразованное значение Decimal.A 16-bit signed integer that represents the converted Decimal.
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в Int16 значения с помощью Decimal оператора Explicit к Int16 преобразованию.The following example converts Decimal numbers to Int16 values by using the explicit Decimal to Int16 conversion operator.
// Example of the explicit conversions from Decimal to short and
// Decimal to unsigned short.
using namespace System;
#define formatter "{0,16}{1,19}{2,19}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int16( Decimal argument )
{
Object^ Int16Value;
Object^ UInt16Value;
// Convert the argument to a short value.
try
{
Int16Value = (short)argument;
}
catch ( Exception^ ex )
{
Int16Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned short value.
try
{
UInt16Value = (unsigned short)argument;
}
catch ( Exception^ ex )
{
UInt16Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int16Value, UInt16Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"short \nand Decimal to unsigned short generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "short", "unsigned short" );
Console::WriteLine( formatter, "----------------", "-----", "--------------" );
// Convert Decimal values and display the results.
DecimalToU_Int16( Decimal::Parse( "123" ) );
DecimalToU_Int16( Decimal(123000,0,0,false,3) );
DecimalToU_Int16( Decimal::Parse( "123.999" ) );
DecimalToU_Int16( Decimal::Parse( "65535.999" ) );
DecimalToU_Int16( Decimal::Parse( "65536" ) );
DecimalToU_Int16( Decimal::Parse( "32767.999" ) );
DecimalToU_Int16( Decimal::Parse( "32768" ) );
DecimalToU_Int16( Decimal::Parse( "-0.999" ) );
DecimalToU_Int16( Decimal::Parse( "-1" ) );
DecimalToU_Int16( Decimal::Parse( "-32768.999" ) );
DecimalToU_Int16( Decimal::Parse( "-32769" ) );
}
/*
This example of the explicit conversions from Decimal to short
and Decimal to unsigned short generates the following output.
It displays several converted Decimal values.
Decimal argument short unsigned short
---------------- ----- --------------
123 123 123
123.000 123 123
123.999 123 123
65535.999 OverflowException 65535
65536 OverflowException OverflowException
32767.999 32767 32767
32768 OverflowException 32768
-0.999 0 0
-1 -1 OverflowException
-32768.999 -32768 OverflowException
-32769 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to short and
// decimal to ushort.
using System;
class DecimalToU_Int16Demo
{
const string formatter = "{0,16}{1,19}{2,19}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int16( decimal argument )
{
object Int16Value;
object UInt16Value;
// Convert the argument to a short value.
try
{
Int16Value = (short)argument;
}
catch( Exception ex )
{
Int16Value = GetExceptionType( ex );
}
// Convert the argument to a ushort value.
try
{
UInt16Value = (ushort)argument;
}
catch( Exception ex )
{
UInt16Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int16Value, UInt16Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to short \nand decimal to ushort generates the " +
"following output. It displays \nseveral converted " +
"decimal values.\n" );
Console.WriteLine( formatter, "decimal argument",
"short/exception", "ushort/exception" );
Console.WriteLine( formatter, "----------------",
"---------------", "----------------" );
// Convert decimal values and display the results.
DecimalToU_Int16( 123M );
DecimalToU_Int16( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int16( 123.999M );
DecimalToU_Int16( 65535.999M );
DecimalToU_Int16( 65536M );
DecimalToU_Int16( 32767.999M );
DecimalToU_Int16( 32768M );
DecimalToU_Int16( - 0.999M );
DecimalToU_Int16( - 1M );
DecimalToU_Int16( - 32768.999M );
DecimalToU_Int16( - 32769M );
}
}
/*
This example of the explicit conversions from decimal to short
and decimal to ushort generates the following output. It displays
several converted decimal values.
decimal argument short/exception ushort/exception
---------------- --------------- ----------------
123 123 123
123.000 123 123
123.999 123 123
65535.999 OverflowException 65535
65536 OverflowException OverflowException
32767.999 32767 32767
32768 OverflowException 32768
-0.999 0 0
-1 -1 OverflowException
-32768.999 -32768 OverflowException
-32769 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Short and
' Decimal to UShort.
Module DecimalToU_Int16Demo
Const formatter As String = "{0,16}{1,19}{2,19}"
' Convert the decimal argument and catch exceptions that are thrown.
Public Sub DecimalToU_Int16(argument As Decimal)
Dim Int16Value As Object
Dim UInt16Value As Object
' Convert the argument to a Short value.
Try
Int16Value = CShort(argument)
Catch ex As Exception
Int16Value = ex.GetType().Name
End Try
' Convert the argument to a UShort value.
Try
UInt16Value = CUShort(argument)
Catch ex As Exception
UInt16Value = ex.GetType().Name
End Try
Console.WriteLine( formatter, argument, _
Int16Value, UInt16Value )
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal argument", _
"Short/Exception", "UShort/Exception" )
Console.WriteLine( formatter, "----------------", _
"---------------", "----------------" )
' Convert decimal values and display the results.
DecimalToU_Int16(123d)
DecimalToU_Int16(New Decimal( 123000, 0, 0, False, 3 ))
DecimalToU_Int16(123.999d)
DecimalToU_Int16(65535.999d)
DecimalToU_Int16(65536d)
DecimalToU_Int16(32767.999d)
DecimalToU_Int16(32768d)
DecimalToU_Int16(-0.999d)
DecimalToU_Int16(-1d)
DecimalToU_Int16(-32768.999d)
DecimalToU_Int16(-32769d)
End Sub
End Module
' This example displays the following output to the console:
' Decimal argument Short/Exception UShort/Exception
' ---------------- --------------- ----------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 65535.999 OverflowException OverflowException
' 65536 OverflowException OverflowException
' 32767.999 OverflowException 32768
' 32768 OverflowException 32768
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -32768.999 OverflowException OverflowException
' -32769 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в Int16 .This operator supports the explicit conversion of a Decimal to an Int16. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Int16 значение с помощью C#, Visual Basic и C++.The example illustrates the different return values when you explicitly convert a Decimal value to an Int16 value by using C#, Visual Basic, and C++. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToInt16(Decimal) Convert.ToInt16(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToInt16(Decimal) or the Convert.ToInt16(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Double)
public:
static explicit operator double(System::Decimal value);public static explicit operator double (decimal value);static member op_Explicit : decimal -> doublePublic Shared Narrowing Operator CType (value As Decimal) As DoubleПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
Число двойной точности с плавающей запятой, которое представляет преобразованное число Decimal.A double-precision floating-point number that represents the converted Decimal.
Примеры
В следующем примере числа преобразуются Decimal в Double значения с помощью Decimal оператора Explicit к Double преобразованию.The following example converts Decimal numbers to Double values by using the explicit Decimal to Double conversion operator.
using namespace System;
void main()
{
// Define an array of Decimal values.
array<Decimal>^ values = { Decimal::Parse("0.0000000000000000000000000001"),
Decimal::Parse("0.0000000000123456789123456789"),
Decimal::Parse("123"),
Decimal(123000000, 0, 0, false, 6),
Decimal::Parse("123456789.123456789"),
Decimal::Parse("123456789123456789123456789"),
Decimal::MinValue, Decimal::MaxValue };
// Convert each value to a double.
for each (Decimal value in values) {
double dblValue = (double) value;
Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType()->Name, dblValue,
dblValue.GetType()->Name);
}
}
// The example displays the following output:
// 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Double)
// 0.0000000000123456789123456789 (Decimal) --> 1.23456789123457E-11 (Double)
// 123 (Decimal) --> 123 (Double)
// 123.000000 (Decimal) --> 123 (Double)
// 123456789.123456789 (Decimal) --> 123456789.123457 (Double)
// 123456789123456789123456789 (Decimal) --> 1.23456789123457E+26 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.92281625142643E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.92281625142643E+28 (Double)
using System;
class Example
{
public static void Main( )
{
// Define an array of decimal values.
decimal[] values = { 0.0000000000000000000000000001M,
0.0000000000123456789123456789M,
123M, new decimal(123000000, 0, 0, false, 6),
123456789.123456789M,
123456789123456789123456789M,
decimal.MinValue, decimal.MaxValue };
// Convert each value to a double.
foreach (var value in values) {
double dblValue = (double) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, dblValue,
dblValue.GetType().Name);
}
}
}
// The example displays the following output:
// 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Double)
// 0.0000000000123456789123456789 (Decimal) --> 1.23456789123457E-11 (Double)
// 123 (Decimal) --> 123 (Double)
// 123.000000 (Decimal) --> 123 (Double)
// 123456789.123456789 (Decimal) --> 123456789.123457 (Double)
// 123456789123456789123456789 (Decimal) --> 1.23456789123457E+26 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.92281625142643E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.92281625142643E+28 (Double)
Module Example
Public Sub Main( )
' Define an array of Decimal values.
Dim values() As Decimal= { 0.0000000000000000000000000001d,
0.0000000000123456789123456789d,
123d,
New Decimal(123000000, 0, 0, False, 6),
123456789.123456789d,
123456789123456789123456789d,
Decimal.MinValue, Decimal.MaxValue }
For Each value In values
Dim dblValue As Double = CDbl(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, dblValue,
dblValue.GetType().Name)
Next
End Sub
End Module
' The example displays the following output:
' 0.0000000000000000000000000001 (Decimal) --> 1E-28 (Double)
' 0.0000000000123456789123456789 (Decimal) --> 1.23456789123457E-11 (Double)
' 123 (Decimal) --> 123 (Double)
' 123.000000 (Decimal) --> 123 (Double)
' 123456789.123456789 (Decimal) --> 123456789.123457 (Double)
' 123456789123456789123456789 (Decimal) --> 1.23456789123457E+26 (Double)
' -79228162514264337593543950335 (Decimal) --> -7.92281625142643E+28 (Double)
' 79228162514264337593543950335 (Decimal) --> 7.92281625142643E+28 (Double)
Комментарии
Эта операция может привести к утрате точности, так как число с плавающей запятой двойной точности содержит меньше значащих цифр, чем Decimal .This operation can result in a loss of precision, because a double-precision floating-point number has fewer significant digits than a Decimal.
Этот оператор поддерживает явное преобразование типа Decimal в Double .This operator supports the explicit conversion of a Decimal to a Double. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Double значение с помощью C#, C++ и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a Double value by using C#, C++, and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToDouble(Decimal) Convert.ToDouble(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToDouble(Decimal) or the Convert.ToDouble(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Char)
public:
static explicit operator char(System::Decimal value);public static explicit operator char (decimal value);static member op_Explicit : decimal -> charPublic Shared Narrowing Operator CType (value As Decimal) As CharПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
Символ Юникода, представляющий преобразованное значение типа Decimal.A Unicode character that represents the converted Decimal.
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в Char значения (символы Юникода) с помощью Decimal оператора Explicit To Convert Char .The following example converts Decimal numbers to Char values (Unicode characters) by using the explicit Decimal to Char conversion operator.
using System;
class Example
{
public static void Main( )
{
// Define an array of decimal values.
decimal[] values = { 3.33m, 55.5m, 77.7m, 123m, 123.999m, 170m,
188.88m, 222m, 244m, 8217m, 8250m, 65536m,
-1m };
// Convert each value to a Char.
foreach (decimal value in values) {
try {
char charValue = (char) value;
Console.WriteLine("{0} --> {1} ({2:X4})", value,
charValue, (ushort) charValue);
}
catch (OverflowException) {
Console.WriteLine("OverflowException: Cannot convert {0}",
value);
}
}
}
}
// The example displays the following output:
// 3.33 --> ? (0003)
// 55.5 --> 7 (0037)
// 77.7 --> M (004D)
// 123 --> { (007B)
// 123.999 --> { (007B)
// 170 --> ª (00AA)
// 188.88 --> ¼ (00BC)
// 222 --> _ (00DE)
// 244 --> ô (00F4)
// 8217 --> ' (2019)
// 8250 --> > (203A)
// OverflowException: Cannot convert 65536
// OverflowException: Cannot convert -1
' Visual Basic does not support explicit Decimal-to-Char
' conversion using either CType or CChar.
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в Char .This operator supports the explicit conversion of a Decimal to a Char. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать различные результаты или вообще не поддерживать преобразование.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results, or might not support the conversion at all. Например, компиляторы Visual Basic и C++ не поддерживают явное Decimal Char преобразование.For example, the Visual Basic and C++ compilers do not support an explicit Decimal to a Char conversion.
См. также раздел
Применяется к
Explicit(Decimal to Byte)
public:
static explicit operator System::Byte(System::Decimal value);public static explicit operator byte (decimal value);static member op_Explicit : decimal -> bytePublic Shared Narrowing Operator CType (value As Decimal) As ByteПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
8-разрядное целое число без знака, которое представляет преобразованное значение типа Decimal.An 8-bit unsigned integer that represents the converted Decimal.
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в Byte значения с помощью Decimal оператора Explicit к Byte преобразованию.The following example converts Decimal numbers to Byte values by using the explicit Decimal to Byte conversion operator.
using namespace System;
void main()
{
// Define an array of decimal values.
array<Decimal>^ values = { Decimal::Parse("78"),
Decimal(78000,0,0,false,3),
Decimal::Parse("78.999"),
Decimal::Parse("255.999"),
Decimal::Parse("256"),
Decimal::Parse("127.999"),
Decimal::Parse("128"),
Decimal::Parse("-0.999"),
Decimal::Parse("-1"),
Decimal::Parse("-128.999"),
Decimal::Parse("-129") };
for each (Decimal value in values) {
try {
Byte byteValue = (Byte) value;
Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType()->Name, byteValue,
byteValue.GetType()->Name);
}
catch (OverflowException^ e) {
Console::WriteLine("OverflowException: Cannot convert {0}",
value);
}
}
}
// The example displays the following output:
// 78 (Decimal) --> 78 (Byte)
// 78.000 (Decimal) --> 78 (Byte)
// 78.999 (Decimal) --> 78 (Byte)
// 255.999 (Decimal) --> 255 (Byte)
// OverflowException: Cannot convert 256
// 127.999 (Decimal) --> 127 (Byte)
// 128 (Decimal) --> 128 (Byte)
// -0.999 (Decimal) --> 0 (Byte)
// OverflowException: Cannot convert -1
// OverflowException: Cannot convert -128.999
// OverflowException: Cannot convert -129
using System;
class Example
{
public static void Main()
{
// Define an array of decimal values.
decimal[] values = { 78m, new Decimal(78000, 0, 0, false, 3),
78.999m, 255.999m, 256m, 127.999m,
128m, -0.999m, -1m, -128.999m, -129m };
foreach (var value in values) {
try {
Byte byteValue = (Byte) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, byteValue,
byteValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("OverflowException: Cannot convert {0}",
value);
}
}
}
}
// The example displays the following output:
// 78 (Decimal) --> 78 (Byte)
// 78.000 (Decimal) --> 78 (Byte)
// 78.999 (Decimal) --> 78 (Byte)
// 255.999 (Decimal) --> 255 (Byte)
// OverflowException: Cannot convert 256
// 127.999 (Decimal) --> 127 (Byte)
// 128 (Decimal) --> 128 (Byte)
// -0.999 (Decimal) --> 0 (Byte)
// OverflowException: Cannot convert -1
// OverflowException: Cannot convert -128.999
// OverflowException: Cannot convert -129
Option Strict On
Module Example
Public Sub Main()
' Define an array of decimal values.
Dim values() As Decimal = { 78d, New Decimal(78000, 0, 0, False, 3),
78.999d, 255.999d, 256d, 127.999d,
128d, -0.999d, -1d, -128.999d,
-129d }
For Each value In values
Try
Dim byteValue As Byte = CByte(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
value.GetType().Name, byteValue,
byteValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("OverflowException: Cannot convert {0}",
value)
End Try
Next
End Sub
End Module
' The example displays the following output:
' 78 (Decimal) --> 78 (Byte)
' 78.000 (Decimal) --> 78 (Byte)
' 78.999 (Decimal) --> 79 (Byte)
' OverflowException: Cannot convert 255.999
' OverflowException: Cannot convert 256
' 127.999 (Decimal) --> 128 (Byte)
' 128 (Decimal) --> 128 (Byte)
' OverflowException: Cannot convert -0.999
' OverflowException: Cannot convert -1
' OverflowException: Cannot convert -128.999
' OverflowException: Cannot convert -129
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в Byte .This operator supports the explicit conversion of a Decimal to a Byte. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Byte значение с помощью C#, C++ и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to a Byte value by using C#, C++, and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToByte(Decimal) Convert.ToByte(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToByte(Decimal) or the Convert.ToByte(Decimal) method.
См. также раздел
Применяется к
Explicit(Decimal to Int64)
public:
static explicit operator long(System::Decimal value);public static explicit operator long (decimal value);static member op_Explicit : decimal -> int64Public Shared Narrowing Operator CType (value As Decimal) As LongПараметры
- value
- Decimal
Преобразуемое значение.The value to convert.
Возвращаемое значение
64-разрядное целое число со знаком, которое представляет преобразованное значение Decimal.A 64-bit signed integer that represents the converted Decimal.
Исключения
Значение value меньше MinValue или больше MaxValue.value is less than MinValue or greater than MaxValue.
Примеры
В следующем примере числа преобразуются Decimal в Int64 значения с помощью Decimal оператора Explicit к Int64 преобразованию.The following example converts Decimal numbers to Int64 values by using the explicit Decimal to Int64 conversion operator.
// Example of the explicit conversions from Decimal to __int64 and
// Decimal to unsigned __int64.
using namespace System;
#define formatter "{0,25}{1,22}{2,22}"
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToU_Int64( Decimal argument )
{
Object^ Int64Value;
Object^ UInt64Value;
// Convert the argument to an __int64 value.
try
{
Int64Value = (__int64)argument;
}
catch ( Exception^ ex )
{
Int64Value = GetExceptionType( ex );
}
// Convert the argument to an unsigned __int64 value.
try
{
UInt64Value = (unsigned __int64)argument;
}
catch ( Exception^ ex )
{
UInt64Value = GetExceptionType( ex );
}
Console::WriteLine( formatter, argument, Int64Value, UInt64Value );
}
int main()
{
Console::WriteLine( "This example of the explicit conversions from Decimal to "
"__int64 \nand Decimal to unsigned __int64 generates the "
"following output. \nIt displays several converted Decimal "
"values.\n" );
Console::WriteLine( formatter, "Decimal argument", "__int64", "unsigned __int64" );
Console::WriteLine( formatter, "----------------", "-------", "----------------" );
// Convert Decimal values and display the results.
DecimalToU_Int64( Decimal::Parse( "123" ) );
DecimalToU_Int64( Decimal(123000,0,0,false,3) );
DecimalToU_Int64( Decimal::Parse( "123.999" ) );
DecimalToU_Int64( Decimal::Parse( "18446744073709551615.999" ) );
DecimalToU_Int64( Decimal::Parse( "18446744073709551616" ) );
DecimalToU_Int64( Decimal::Parse( "9223372036854775807.999" ) );
DecimalToU_Int64( Decimal::Parse( "9223372036854775808" ) );
DecimalToU_Int64( Decimal::Parse( "-0.999" ) );
DecimalToU_Int64( Decimal::Parse( "-1" ) );
DecimalToU_Int64( Decimal::Parse( "-9223372036854775808.999" ) );
DecimalToU_Int64( Decimal::Parse( "-9223372036854775809" ) );
}
/*
This example of the explicit conversions from Decimal to __int64
and Decimal to unsigned __int64 generates the following output.
It displays several converted Decimal values.
Decimal argument __int64 unsigned __int64
---------------- ------- ----------------
123 123 123
123.000 123 123
123.999 123 123
18446744073709551615.999 OverflowException 18446744073709551615
18446744073709551616 OverflowException OverflowException
9223372036854775807.999 9223372036854775807 9223372036854775807
9223372036854775808 OverflowException 9223372036854775808
-0.999 0 0
-1 -1 OverflowException
-9223372036854775808.999 -9223372036854775808 OverflowException
-9223372036854775809 OverflowException OverflowException
*/
// Example of the explicit conversions from decimal to long and
// decimal to ulong.
using System;
class DecimalToU_Int64Demo
{
const string formatter = "{0,25}{1,22}{2,22}";
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
// Convert the decimal argument; catch exceptions that are thrown.
public static void DecimalToU_Int64( decimal argument )
{
object Int64Value;
object UInt64Value;
// Convert the argument to a long value.
try
{
Int64Value = (long)argument;
}
catch( Exception ex )
{
Int64Value = GetExceptionType( ex );
}
// Convert the argument to a ulong value.
try
{
UInt64Value = (ulong)argument;
}
catch( Exception ex )
{
UInt64Value = GetExceptionType( ex );
}
Console.WriteLine( formatter, argument,
Int64Value, UInt64Value );
}
public static void Main( )
{
Console.WriteLine(
"This example of the explicit conversions from decimal " +
"to long \nand decimal to ulong generates the following " +
"output. It displays \nseveral converted decimal " +
"values.\n" );
Console.WriteLine( formatter, "decimal argument",
"long/exception", "ulong/exception" );
Console.WriteLine( formatter, "----------------",
"--------------", "---------------" );
// Convert decimal values and display the results.
DecimalToU_Int64( 123M );
DecimalToU_Int64( new decimal( 123000, 0, 0, false, 3 ) );
DecimalToU_Int64( 123.999M );
DecimalToU_Int64( 18446744073709551615.999M );
DecimalToU_Int64( 18446744073709551616M );
DecimalToU_Int64( 9223372036854775807.999M );
DecimalToU_Int64( 9223372036854775808M );
DecimalToU_Int64( - 0.999M );
DecimalToU_Int64( - 1M );
DecimalToU_Int64( - 9223372036854775808.999M );
DecimalToU_Int64( - 9223372036854775809M );
}
}
/*
This example of the explicit conversions from decimal to long
and decimal to ulong generates the following output. It displays
several converted decimal values.
decimal argument long/exception ulong/exception
---------------- -------------- ---------------
123 123 123
123.000 123 123
123.999 123 123
18446744073709551615.999 OverflowException 18446744073709551615
18446744073709551616 OverflowException OverflowException
9223372036854775807.999 9223372036854775807 9223372036854775807
9223372036854775808 OverflowException 9223372036854775808
-0.999 0 0
-1 -1 OverflowException
-9223372036854775808.999 -9223372036854775808 OverflowException
-9223372036854775809 OverflowException OverflowException
*/
' Example of the explicit conversions from Decimal to Long and
' Decimal to ULong.
Module DecimalToU_Int64Demo
Const formatter As String = "{0,25}{1,22}{2,22}"
' Convert the decimal argument catch exceptions that are thrown.
Public Sub DecimalToU_Int64(argument As Decimal)
Dim Int64Value As Object
Dim UInt64Value As Object
' Convert the argument to a long value.
Try
Int64Value = CLng(argument)
Catch ex As Exception
Int64Value = ex.GetType().Name
End Try
' Convert the argument to a ulong value.
Try
UInt64Value = CULng(argument)
Catch ex As Exception
UInt64Value = ex.GetType().Name
End Try
Console.WriteLine(formatter, argument, _
Int64Value, UInt64Value)
End Sub
Public Sub Main( )
Console.WriteLine( formatter, "Decimal argument", _
"Long/Exception", "ULong/Exception" )
Console.WriteLine( formatter, "----------------", _
"--------------", "---------------" )
' Convert decimal values and display the results.
DecimalToU_Int64(123d)
DecimalToU_Int64(New Decimal(123000, 0, 0, False, 3))
DecimalToU_Int64(123.999d)
DecimalToU_Int64(18446744073709551615.999d)
DecimalToU_Int64(18446744073709551616d)
DecimalToU_Int64(9223372036854775807.999d)
DecimalToU_Int64(9223372036854775808d)
DecimalToU_Int64(-0.999d)
DecimalToU_Int64(-1d)
DecimalToU_Int64(-9223372036854775808.999d)
DecimalToU_Int64(-9223372036854775809d)
End Sub
End Module
' The example displays the following output to the console:
' Decimal argument Long/Exception ULong/Exception
' ---------------- -------------- ---------------
' 123 123 123
' 123.000 123 123
' 123.999 124 124
' 18446744073709551615.999 OverflowException OverflowException
' 18446744073709551616 OverflowException OverflowException
' 9223372036854775807.999 OverflowException 9223372036854775808
' 9223372036854775808 OverflowException 9223372036854775808
' -0.999 -1 OverflowException
' -1 -1 OverflowException
' -9223372036854775808.999 OverflowException OverflowException
' -9223372036854775809 OverflowException OverflowException
Комментарии
Этот оператор поддерживает явное преобразование типа Decimal в Int64 .This operator supports the explicit conversion of a Decimal to an Int64. Синтаксис таких явных преобразований зависит от языка, а компиляторы отдельных языков могут предоставлять различные реализации и возвращать разные результаты.The syntax for such explicit conversions is language-dependent, and individual language compilers can provide different implementations and return different results. В примере показаны различные возвращаемые значения при явном преобразовании Decimal значения в Int64 значение с помощью C# и Visual Basic.The example illustrates the different return values when you explicitly convert a Decimal value to an Int64 value by using C# and Visual Basic. Чтобы выполнить преобразование, независимое от языка, можно вызвать Decimal.ToInt64(Decimal) Convert.ToInt64(Decimal) метод или.To perform a conversion that is independent of language, you can call the Decimal.ToInt64(Decimal) or the Convert.ToInt64(Decimal) method.