Decimal.Explicit 操作员

定义

命名空间:

System

程序集:

System.Runtime.dll

定义 Decimal 对象与其他类型之间的显式转换。

重载

Explicit(Single to Decimal)	定义从单精度浮点数到 Decimal 的显式转换。
Explicit(Double to Decimal)	定义从双精度浮点数到 Decimal 的显式转换。
Explicit(Decimal to UInt64)	定义从 Decimal 到 64 位无符号整数的显式转换。 此 API 不兼容 CLS。
Explicit(Decimal to UInt32)	定义从 Decimal 到 32 位无符号整数的显式转换。 此 API 不兼容 CLS。
Explicit(Decimal to UInt16)	定义从 Decimal 到 16 位无符号整数的显式转换。 此 API 不兼容 CLS。
Explicit(Decimal to SByte)	定义从 Decimal 到 8 位有符号整数的显式转换。 此 API 不兼容 CLS。
Explicit(Decimal to Single)	定义从 Decimal 到单精度浮点数的显式转换。
Explicit(Decimal to Int32)	定义从 Decimal 到 32 位有符号整数的显式转换。
Explicit(Decimal to Int16)	定义从 Decimal 到 16 位有符号整数的显式转换。
Explicit(Decimal to Double)	定义从 Decimal 到双精度浮点数的显式转换。
Explicit(Decimal to Char)	定义从 Unicode 字符到 Decimal 的显式转换。
Explicit(Decimal to Byte)	定义从 Decimal 到 8 位无符号整数的显式转换。
Explicit(Decimal to Int64)	定义从 Decimal 到 64 位有符号整数的显式转换。

Explicit(Single to Decimal)

Source:

Decimal.cs

定义从单精度浮点数到 Decimal 的显式转换。

C#

public static explicit operator decimal (float value);

参数

value

Single

要转换的单精度浮点数。

返回

Decimal

已转换的单精度浮点数。

例外

OverflowException

value 大于 Decimal.MaxValue 或小于 Decimal.MinValue。

- 或 -

value 为 NaN、PositiveInfinity 或 NegativeInfinity。

示例

以下示例使用 SingleDecimal to 转换Single运算符将值Decimal转换为数字。 此转换需要 Visual Basic 中的 op_Explicit 运算符。

C#

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

另请参阅

• Single

Explicit(Double to Decimal)

Source:

Decimal.cs

定义从双精度浮点数到 Decimal 的显式转换。

C#

public static explicit operator decimal (double value);

参数

value

Double

要转换的双精度浮点数。

返回

Decimal

已转换的双精度浮点数。

例外

OverflowException

value 大于 Decimal.MaxValue 或小于 Decimal.MinValue。

- 或 -

value 为 NaN、PositiveInfinity 或 NegativeInfinity。

示例

以下示例使用 DoubleDecimal to 转换Double运算符将值Decimal转换为数字。 此转换需要 Visual Basic 中的 op_Explicit 运算符。

C#

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

另请参阅

• Double

Explicit(Decimal to UInt64)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 Decimal 到 64 位无符号整数的显式转换。

此 API 不兼容 CLS。

C#

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

参数

value

Decimal

要转换的值。

返回

UInt64

64 位无符号整数，它表示转换后的 Decimal。

属性

CLSCompliantAttribute

例外

OverflowException

value 为负或大于 UInt64.MaxValue。

示例

以下示例使用显式Decimal到UInt64转换Decimal运算符将数字转换为UInt64值。

C#

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

注解

此运算符支持将 显式DecimalUInt64转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值DecimalUInt64显式转换为值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToUInt64(Decimal) 或 Convert.ToUInt64(Decimal) 方法。

另请参阅

• UInt64

Explicit(Decimal to UInt32)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案

System.Decimal.ToInt64(Decimal)

定义从 Decimal 到 32 位无符号整数的显式转换。

此 API 不兼容 CLS。

C#

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

参数

value

Decimal

要转换的值。

返回

UInt32

32 位无符号整数，它表示转换后的 Decimal。

属性

CLSCompliantAttribute

例外

OverflowException

value 小于 UInt32.MinValue 或大于 UInt32.MaxValue。

示例

以下示例使用显式Decimal到UInt32转换Decimal运算符将数字转换为UInt32值。

C#

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

注解

此运算符支持将 显式DecimalUInt32转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值DecimalUInt32显式转换为值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToUInt32(Decimal) 或 Convert.ToUInt32(Decimal) 方法。

另请参阅

• UInt32

Explicit(Decimal to UInt16)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 Decimal 到 16 位无符号整数的显式转换。

此 API 不兼容 CLS。

C#

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

参数

value

Decimal

要转换的值。

返回

UInt16

16 位无符号整数，它表示转换后的 Decimal。

属性

CLSCompliantAttribute

例外

OverflowException

value 小于 UInt16.MinValue 或大于 UInt16.MaxValue。

示例

以下示例使用显式Decimal到UInt16转换Decimal运算符将数字转换为UInt16值。

C#

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

注解

此运算符支持将 显式DecimalUInt16转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值DecimalUInt16显式转换为值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToUInt16(Decimal) 或 Convert.ToUInt16(Decimal) 方法。

另请参阅

• UInt16

Explicit(Decimal to SByte)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案

System.Decimal.ToInt16(Decimal)

定义从 Decimal 到 8 位有符号整数的显式转换。

此 API 不兼容 CLS。

C#

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

参数

value

Decimal

要转换的值。

返回

SByte

8 位有符号整数，它表示转换后的 Decimal。

属性

CLSCompliantAttribute

例外

OverflowException

value 小于 SByte.MinValue 或大于 SByte.MaxValue。

示例

以下示例使用显式Decimal到SByte转换Decimal运算符将数字转换为SByte值。

C#

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

注解

此运算符支持将 显式DecimalSByte转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值Byte显式转换为 Decimal 和 SByte 值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToSByte(Decimal) 方法或 Convert.ToSByte(Decimal) 方法。

另请参阅

• SByte

Explicit(Decimal to Single)

Source:

Decimal.cs

定义从 Decimal 到单精度浮点数的显式转换。

C#

public static explicit operator float (decimal value);

参数

value

Decimal

要转换的值。

返回

Single

单精度浮点数，它表示转换后的 Decimal。

示例

以下示例使用显式Decimal到Single转换Decimal运算符将数字转换为Single值。

C#

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)

注解

此操作可能会导致精度损失，因为单精度浮点数比 Decimal具有更少的有效数字。

此运算符支持将 显式DecimalSingle转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值DecimalSingle显式转换为值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToSingle(Decimal) 或 Convert.ToSingle(Decimal) 方法。

另请参阅

• Single

Explicit(Decimal to Int32)

Source:

Decimal.cs

定义从 Decimal 到 32 位有符号整数的显式转换。

C#

public static explicit operator int (decimal value);

参数

value

Decimal

要转换的值。

返回

Int32

32 位有符号整数，它表示转换后的 Decimal。

例外

OverflowException

value 小于 Int32.MinValue 或大于 Int32.MaxValue。

示例

以下示例使用显式Decimal到Int32转换Decimal运算符将数字转换为Int32值。

C#

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

注解

此运算符支持将 显式DecimalInt32转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示使用 C#、C++ 和 Visual Basic 将值Int32显式转换为Decimal值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToInt32(Decimal) 或 Convert.ToInt32(Decimal) 方法。

另请参阅

• Int32

Explicit(Decimal to Int16)

Source:

Decimal.cs

定义从 Decimal 到 16 位有符号整数的显式转换。

C#

public static explicit operator short (decimal value);

参数

value

Decimal

要转换的值。

返回

Int16

16 位有符号整数，它表示转换后的 Decimal。

例外

OverflowException

value 小于 Int16.MinValue 或大于 Int16.MaxValue。

示例

以下示例使用显式Decimal到Int16转换Decimal运算符将数字转换为Int16值。

C#

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

注解

此运算符支持将 显式DecimalInt16转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C#、Visual Basic 和 C++ 将值显式转换为DecimalInt16值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToInt16(Decimal) 或 Convert.ToInt16(Decimal) 方法。

另请参阅

• Int16

Explicit(Decimal to Double)

Source:

Decimal.cs

定义从 Decimal 到双精度浮点数的显式转换。

C#

public static explicit operator double (decimal value);

参数

value

Decimal

要转换的值。

返回

Double

双精度浮点数，它表示转换后的 Decimal。

示例

以下示例使用显式Decimal到Double转换Decimal运算符将数字转换为Double值。

C#

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)

注解

此操作可能会导致精度损失，因为双精度浮点数比 Decimal具有更少的有效数字。

此运算符支持将 显式DecimalDouble转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示使用 C#、C++ 和 Visual Basic 将值Double显式转换为Decimal值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToDouble(Decimal) 或 Convert.ToDouble(Decimal) 方法。

另请参阅

• Double

Explicit(Decimal to Char)

Source:

Decimal.cs

定义从 Unicode 字符到 Decimal 的显式转换。

C#

public static explicit operator char (decimal value);

参数

value

Decimal

要转换的值。

返回

Char

表示转换后的 Decimal 的 Unicode 字符。

例外

OverflowException

value 小于 Char.MinValue 或大于 Char.MaxValue。

示例

下面的示例使用显式DecimalChar到转换运算符将数字Char转换为Decimal (Unicode 字符) 的值。

C#

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

注解

此运算符支持将 显式DecimalChar转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果，或者可能根本不支持转换。 例如，Visual Basic 和 C++ 编译器不支持显式 Decimal 到 的 Char 转换。

另请参阅

• Char

Explicit(Decimal to Byte)

Source:

Decimal.cs

定义从 Decimal 到 8 位无符号整数的显式转换。

C#

public static explicit operator byte (decimal value);

参数

value

Decimal

要转换的值。

返回

Byte

8 位无符号整数，它表示转换后的 Decimal。

例外

OverflowException

value 小于 Byte.MinValue 或大于 Byte.MaxValue。

示例

以下示例使用显式Decimal到Byte转换Decimal运算符将数字转换为Byte值。

C#

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

注解

此运算符支持将 显式DecimalByte转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示使用 C#、C++ 和 Visual Basic 将值Byte显式转换为Decimal值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToByte(Decimal) 或 Convert.ToByte(Decimal) 方法。

另请参阅

• Byte

Explicit(Decimal to Int64)

Source:

Decimal.cs

定义从 Decimal 到 64 位有符号整数的显式转换。

C#

public static explicit operator long (decimal value);

参数

value

Decimal

要转换的值。

返回

Int64

64 位有符号整数，它表示转换后的 Decimal。

例外

OverflowException

value 小于 Int64.MinValue 或大于 Int64.MaxValue。

示例

以下示例使用显式Decimal到Int64转换Decimal运算符将数字转换为Int64值。

C#

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

注解

此运算符支持将 显式DecimalInt64转换为 。 此类显式转换的语法依赖于语言，各个语言编译器可以提供不同的实现并返回不同的结果。 此示例演示了使用 C# 和 Visual Basic 将值Int64显式转换为Decimal值时的不同返回值。 若要执行独立于语言的转换，可以调用 Decimal.ToInt64(Decimal) 或 Convert.ToInt64(Decimal) 方法。

另请参阅

• Int64