Decimal.Explicit Decimal.Explicit Decimal.Explicit Decimal.Explicit Operator

定義

多載

Explicit(Single to Decimal) Explicit(Single to Decimal) Explicit(Single to Decimal) Explicit(Single to Decimal)

定義從單精確度浮點數到 Decimal 的明確轉換。Defines an explicit conversion of a single-precision floating-point number to a Decimal.

Explicit(Double to Decimal) Explicit(Double to Decimal) Explicit(Double to Decimal) Explicit(Double to Decimal)

定義從雙精確度浮點數到 Decimal 的明確轉換。Defines an explicit conversion of a double-precision floating-point number to a Decimal.

Explicit(Decimal to UInt32) Explicit(Decimal to UInt32) Explicit(Decimal to UInt32) Explicit(Decimal to UInt32)

定義從 Decimal 到 32 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 32-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

Explicit(Decimal to UInt16) Explicit(Decimal to UInt16) Explicit(Decimal to UInt16) Explicit(Decimal to UInt16)

定義從 Decimal 到 16 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 16-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

Explicit(Decimal to Single) Explicit(Decimal to Single) Explicit(Decimal to Single) Explicit(Decimal to Single)

定義從 Decimal 到單精確度浮點數的明確轉換。Defines an explicit conversion of a Decimal to a single-precision floating-point number.

Explicit(Decimal to SByte) Explicit(Decimal to SByte) Explicit(Decimal to SByte) Explicit(Decimal to SByte)

定義從 Decimal 到 8 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to an 8-bit signed integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

Explicit(Decimal to UInt64) Explicit(Decimal to UInt64) Explicit(Decimal to UInt64) Explicit(Decimal to UInt64)

定義從 Decimal 到 64 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 64-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

Explicit(Decimal to Int32) Explicit(Decimal to Int32) Explicit(Decimal to Int32) Explicit(Decimal to Int32)

定義從 Decimal 到 32 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 32-bit signed integer.

Explicit(Decimal to Int16) Explicit(Decimal to Int16) Explicit(Decimal to Int16) Explicit(Decimal to Int16)

定義從 Decimal 到 16 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 16-bit signed integer.

Explicit(Decimal to Double) Explicit(Decimal to Double) Explicit(Decimal to Double) Explicit(Decimal to Double)

定義從 Decimal 到雙精確度浮點數的明確轉換。Defines an explicit conversion of a Decimal to a double-precision floating-point number.

Explicit(Decimal to Char) Explicit(Decimal to Char) Explicit(Decimal to Char) Explicit(Decimal to Char)

定義從 Decimal 到 Unicode 字元的明確轉換。Defines an explicit conversion of a Decimal to a Unicode character.

Explicit(Decimal to Byte) Explicit(Decimal to Byte) Explicit(Decimal to Byte) Explicit(Decimal to Byte)

定義從 Decimal 到 8 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to an 8-bit unsigned integer.

Explicit(Decimal to Int64) Explicit(Decimal to Int64) Explicit(Decimal to Int64) Explicit(Decimal to Int64)

定義從 Decimal 到 64 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 64-bit signed integer.

Explicit(Single to Decimal) Explicit(Single to Decimal) Explicit(Single to Decimal) Explicit(Single to Decimal)

定義從單精確度浮點數到 Decimal 的明確轉換。Defines an explicit conversion of a single-precision floating-point number to a Decimal.

public:
 static explicit operator System::Decimal(float value);
public static explicit operator decimal (float value);
static member op_Explicit : single -> decimal
Public Shared Narrowing Operator CType (value As Single) As Decimal

參數

value
Single Single Single Single

要轉換的單精確度浮點數。The single-precision floating-point number to convert.

傳回

轉換的單精確度浮點數。The converted single-precision floating point number.

例外狀況

value 大於 MaxValue 或小於 MinValuevalue is greater than MaxValue or less than MinValue.

-或--or- valueNaNPositiveInfinityNegativeInfinityvalue is NaN, PositiveInfinity, or NegativeInfinity.

範例

下列範例會使用Single Decimal Single toDecimal轉換運算子,將值轉換成數位。The following example converts Single values to Decimal numbers by using the Single to Decimal conversion operator. 這項轉換需要 Visual Basic 中的 op_Explicit 運算子。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) Explicit(Double to Decimal) Explicit(Double to Decimal) Explicit(Double to Decimal)

定義從雙精確度浮點數到 Decimal 的明確轉換。Defines an explicit conversion of a double-precision floating-point number to a Decimal.

public:
 static explicit operator System::Decimal(double value);
public static explicit operator decimal (double value);
static member op_Explicit : double -> decimal
Public Shared Narrowing Operator CType (value As Double) As Decimal

參數

value
Double Double Double Double

要轉換的雙精確度浮點數。The double-precision floating-point number to convert.

傳回

轉換的雙精確度浮點數。The converted double-precision floating point number.

例外狀況

value 大於 MaxValue 或小於 MinValuevalue is greater than MaxValue or less than MinValue.

-或--or- valueNaNPositiveInfinityNegativeInfinityvalue is NaN, PositiveInfinity, or NegativeInfinity.

範例

下列範例會使用Double Decimal Double toDecimal轉換運算子,將值轉換成數位。The following example converts Double values to Decimal numbers by using the Double to Decimal conversion operator. 這項轉換需要 Visual Basic 中的 op_Explicit 運算子。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) Explicit(Decimal to UInt32) Explicit(Decimal to UInt32) Explicit(Decimal to UInt32)

重要

此 API 不符合 CLS 規範。

符合 CLS 規範替代方案
System.Decimal.ToInt64(Decimal)

定義從 Decimal 到 32 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 32-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

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

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

32 位元不帶正負號的整數,表示已轉換的 DecimalA 32-bit unsigned integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to UInt32 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 C#和 Visual Basic 將值明確轉換UInt32為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to UInt16) Explicit(Decimal to UInt16) Explicit(Decimal to UInt16)

重要

此 API 不符合 CLS 規範。

定義從 Decimal 到 16 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 16-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

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

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

16 位元不帶正負號的整數,表示已轉換的 DecimalA 16-bit unsigned integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to UInt16 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 C#和 Visual Basic 將值明確轉換UInt16為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Single) Explicit(Decimal to Single) Explicit(Decimal to Single)

定義從 Decimal 到單精確度浮點數的明確轉換。Defines an explicit conversion of a Decimal to a single-precision floating-point number.

public:
 static explicit operator float(System::Decimal value);
public static explicit operator float (decimal value);
static member op_Explicit : decimal -> single
Public Shared Narrowing Operator CType (value As Decimal) As Single

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

單精確度浮點數,表示已轉換的 DecimalA single-precision floating-point number that represents the converted Decimal.

範例

下列範例會使用Decimal explicit Decimal to Single 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 C#和 Visual Basic 將值明確轉換Single為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to SByte) Explicit(Decimal to SByte) Explicit(Decimal to SByte)

重要

此 API 不符合 CLS 規範。

符合 CLS 規範替代方案
System.Decimal.ToInt16(Decimal)

定義從 Decimal 到 8 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to an 8-bit signed integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

public:
 static explicit operator System::SByte(System::Decimal value);
[System.CLSCompliant(false)]
public static explicit operator sbyte (decimal value);
static member op_Explicit : decimal -> sbyte
Public Shared Narrowing Operator CType (value As Decimal) As SByte

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

8 位元帶正負號的整數,表示已轉換的 DecimalAn 8-bit signed integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to SByte 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 C#和 Visual Basic,將值明確轉換Byte為和SByte值時,此範例會說明不同的傳回值。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) Explicit(Decimal to UInt64) Explicit(Decimal to UInt64) Explicit(Decimal to UInt64)

重要

此 API 不符合 CLS 規範。

定義從 Decimal 到 64 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 64-bit unsigned integer.

此應用程式開發介面不符合 CLS 標準。This API is not CLS-compliant.

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

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

64 位元不帶正負號的整數,表示已轉換的 DecimalA 64-bit unsigned integer that represents the converted Decimal.

例外狀況

value 是負值或大於 MaxValuevalue is negative or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to UInt64 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 C#和 Visual Basic 將值明確轉換UInt64為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Int32) Explicit(Decimal to Int32) Explicit(Decimal to Int32)

定義從 Decimal 到 32 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 32-bit signed integer.

public:
 static explicit operator int(System::Decimal value);
public static explicit operator int (decimal value);
static member op_Explicit : decimal -> int
Public Shared Narrowing Operator CType (value As Decimal) As Integer

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

32 位元帶正負號的整數,表示已轉換的 DecimalA 32-bit signed integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to Int32 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 C#、 C++和 Visual Basic,將值明確轉換Int32為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Int16) Explicit(Decimal to Int16) Explicit(Decimal to Int16)

定義從 Decimal 到 16 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 16-bit signed integer.

public:
 static explicit operator short(System::Decimal value);
public static explicit operator short (decimal value);
static member op_Explicit : decimal -> int16
Public Shared Narrowing Operator CType (value As Decimal) As Short

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

16 位元帶正負號的整數,表示已轉換的 DecimalA 16-bit signed integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to Int16 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 C#、Visual Basic 和C++,將值明確轉換Int16為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Double) Explicit(Decimal to Double) Explicit(Decimal to Double)

定義從 Decimal 到雙精確度浮點數的明確轉換。Defines an explicit conversion of a Decimal to a double-precision floating-point number.

public:
 static explicit operator double(System::Decimal value);
public static explicit operator double (decimal value);
static member op_Explicit : decimal -> double
Public Shared Narrowing Operator CType (value As Decimal) As Double

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

雙精確度浮點數,表示已轉換的 DecimalA double-precision floating-point number that represents the converted Decimal.

範例

下列範例會使用Decimal explicit Decimal to Double 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 C#、 C++和 Visual Basic,將值明確轉換Double為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Char) Explicit(Decimal to Char) Explicit(Decimal to Char)

定義從 Decimal 到 Unicode 字元的明確轉換。Defines an explicit conversion of a Decimal to a Unicode character.

public:
 static explicit operator char(System::Decimal value);
public static explicit operator char (decimal value);
static member op_Explicit : decimal -> char
Public Shared Narrowing Operator CType (value As Decimal) As Char

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

Unicode 字元,表示已轉換的 DecimalA Unicode character that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal明確Decimal 轉換Char運算子,將數位轉換成Char值(Unicode 字元)。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) Explicit(Decimal to Byte) Explicit(Decimal to Byte) Explicit(Decimal to Byte)

定義從 Decimal 到 8 位元不帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to an 8-bit unsigned integer.

public:
 static explicit operator System::Byte(System::Decimal value);
public static explicit operator byte (decimal value);
static member op_Explicit : decimal -> byte
Public Shared Narrowing Operator CType (value As Decimal) As Byte

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

8 位元不帶正負號的整數,表示已轉換的 DecimalAn 8-bit unsigned integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to Byte 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 C#、 C++和 Visual Basic,將值明確轉換Byte為值時,此範例會說明不同的傳回值。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) Explicit(Decimal to Int64) Explicit(Decimal to Int64) Explicit(Decimal to Int64)

定義從 Decimal 到 64 位元帶正負號整數的明確轉換。Defines an explicit conversion of a Decimal to a 64-bit signed integer.

public:
 static explicit operator long(System::Decimal value);
public static explicit operator long (decimal value);
static member op_Explicit : decimal -> int64
Public Shared Narrowing Operator CType (value As Decimal) As Long

參數

value
Decimal Decimal Decimal Decimal

要進行轉換的值。The value to convert.

傳回

64 位元帶正負號的整數,表示已轉換的 DecimalA 64-bit signed integer that represents the converted Decimal.

例外狀況

value 小於 MinValue 或大於 MaxValuevalue is less than MinValue or greater than MaxValue.

範例

下列範例會使用Decimal explicit Decimal to Int64 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 C#和 Visual Basic 將值明確轉換Int64為值時,此範例會說明不同的傳回值。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.

另請參閱

適用於