Decimal.ToDouble(Decimal) Decimal.ToDouble(Decimal) Decimal.ToDouble(Decimal) Decimal.ToDouble(Decimal) Method

Definición

Convierte el valor del Decimal especificado en el número de punto flotante de precisión doble equivalente.Converts the value of the specified Decimal to the equivalent double-precision floating-point number.

public:
 static double ToDouble(System::Decimal d);
public static double ToDouble (decimal d);
static member ToDouble : decimal -> double
Public Shared Function ToDouble (d As Decimal) As Double

Parámetros

d
Decimal Decimal Decimal Decimal

Número decimal que se va a convertir.The decimal number to convert.

Devoluciones

Número de punto flotante de precisión doble equivalente a d.A double-precision floating-point number equivalent to d.

Ejemplos

En el ejemplo de código siguiente Decimal se convierten números ToDouble en Double valores mediante el método.The following code example converts Decimal numbers to Double values using ToDouble method.

// Example of the Decimal::ToSingle and Decimal::ToDouble methods.
using namespace System;
#define formatter "{0,30}{1,17}{2,23}"

// Convert the Decimal argument; no exceptions are thrown.
void DecimalToSgl_Dbl( Decimal argument )
{
   Object^ SingleValue;
   Object^ DoubleValue;
   
   // Convert the argument to a float value.
   SingleValue = Decimal::ToSingle( argument );
   
   // Convert the argument to a double value.
   DoubleValue = Decimal::ToDouble( argument );
   Console::WriteLine( formatter, argument, SingleValue, DoubleValue );
}

int main()
{
   Console::WriteLine( "This example of the \n"
   "  Decimal::ToSingle( Decimal ) and \n"
   "  Decimal::ToDouble( Decimal ) \nmethods "
   "generates the following output. It \ndisplays "
   "several converted Decimal values.\n" );
   Console::WriteLine( formatter, "Decimal argument", "float", "double" );
   Console::WriteLine( formatter, "----------------", "-----", "------" );
   
   // Convert Decimal values and display the results.
   DecimalToSgl_Dbl( Decimal::Parse(  "0.0000000000000000000000000001" ) );
   DecimalToSgl_Dbl( Decimal::Parse(  "0.0000000000123456789123456789" ) );
   DecimalToSgl_Dbl( Decimal::Parse(  "123" ) );
   DecimalToSgl_Dbl( Decimal(123000000,0,0,false,6) );
   DecimalToSgl_Dbl( Decimal::Parse(  "123456789.123456789" ) );
   DecimalToSgl_Dbl( Decimal::Parse(  "123456789123456789123456789" ) );
   DecimalToSgl_Dbl( Decimal::MinValue );
   DecimalToSgl_Dbl( Decimal::MaxValue );
}

/*
This example of the
  Decimal::ToSingle( Decimal ) and
  Decimal::ToDouble( Decimal )
methods generates the following output. It
displays several converted Decimal values.

              Decimal argument            float                 double
              ----------------            -----                 ------
0.0000000000000000000000000001            1E-28                  1E-28
0.0000000000123456789123456789     1.234568E-11   1.23456789123457E-11
                           123              123                    123
                    123.000000              123                    123
           123456789.123456789     1.234568E+08       123456789.123457
   123456789123456789123456789     1.234568E+26   1.23456789123457E+26
-79228162514264337593543950335    -7.922816E+28  -7.92281625142643E+28
 79228162514264337593543950335     7.922816E+28   7.92281625142643E+28
*/
// Example of the decimal.ToSingle and decimal.ToDouble methods.
using System;

class DecimalToSgl_DblDemo
{
    static string formatter = "{0,30}{1,17}{2,23}";

    // Convert the decimal argument; no exceptions are thrown.
    public static void DecimalToSgl_Dbl( decimal argument )
    {
        object SingleValue;
        object DoubleValue;

        // Convert the argument to a float value.
        SingleValue = decimal.ToSingle( argument );

        // Convert the argument to a double value.
        DoubleValue = decimal.ToDouble( argument );

        Console.WriteLine( formatter, argument, 
            SingleValue, DoubleValue );
    }

    public static void Main( )
    {
        Console.WriteLine( "This example of the \n" +
            "  decimal.ToSingle( decimal ) and \n" +
            "  decimal.ToDouble( decimal ) \nmethods " +
            "generates the following output. It \ndisplays " +
            "several converted decimal values.\n" );
        Console.WriteLine( formatter, "decimal argument", 
            "float", "double" );
        Console.WriteLine( formatter, "----------------", 
            "-----", "------" );

        // Convert decimal values and display the results.
        DecimalToSgl_Dbl( 0.0000000000000000000000000001M );
        DecimalToSgl_Dbl( 0.0000000000123456789123456789M );
        DecimalToSgl_Dbl( 123M );
        DecimalToSgl_Dbl( new decimal( 123000000, 0, 0, false, 6 ) );
        DecimalToSgl_Dbl( 123456789.123456789M );
        DecimalToSgl_Dbl( 123456789123456789123456789M );
        DecimalToSgl_Dbl( decimal.MinValue );
        DecimalToSgl_Dbl( decimal.MaxValue );
    }
}

/*
This example of the
  decimal.ToSingle( decimal ) and
  decimal.ToDouble( decimal )
methods generates the following output. It
displays several converted decimal values.

              decimal argument            float                 double
              ----------------            -----                 ------
0.0000000000000000000000000001            1E-28                  1E-28
0.0000000000123456789123456789     1.234568E-11   1.23456789123457E-11
                           123              123                    123
                    123.000000              123                    123
           123456789.123456789     1.234568E+08       123456789.123457
   123456789123456789123456789     1.234568E+26   1.23456789123457E+26
-79228162514264337593543950335    -7.922816E+28  -7.92281625142643E+28
 79228162514264337593543950335     7.922816E+28   7.92281625142643E+28
*/
' Example of the Decimal.ToSingle and Decimal.ToDouble methods.
Module DecimalToSgl_DblDemo

    Dim formatter As String = "{0,30}{1,17}{2,23}"

    ' Convert the Decimal argument; no exceptions are thrown.
    Sub DecimalToSgl_Dbl( argument As Decimal )

        Dim SingleValue   As Object
        Dim DoubleValue   As Object

        ' Convert the argument to a Single value.
        SingleValue = Decimal.ToSingle( argument )

        ' Convert the argument to a Double value.
        DoubleValue = Decimal.ToDouble( argument )

        Console.WriteLine( formatter, argument, _
            SingleValue, DoubleValue )
    End Sub

    Sub Main( )

        Console.WriteLine( "This example of the " & vbCrLf & _
            "  Decimal.ToSingle( Decimal ) and " & vbCrLf & _
            "  Decimal.ToDouble( Decimal ) " & vbCrLf & "methods " & _
            "generates the following output. It " & vbCrLf & _
            "displays several converted Decimal values." & vbCrLf )
        Console.WriteLine( formatter, "Decimal argument", _
            "Single", "Double" )
        Console.WriteLine( formatter, "----------------", _
            "------", "------" )

        ' Convert Decimal values and display the results.
        DecimalToSgl_Dbl( 0.0000000000000000000000000001D )
        DecimalToSgl_Dbl( 0.0000000000112233445566778899D )
        DecimalToSgl_Dbl( 123D )
        DecimalToSgl_Dbl( New Decimal( 123000000, 0, 0, False, 6 ) )
        DecimalToSgl_Dbl( 123456789.123456789D )
        DecimalToSgl_Dbl( 123456789123456789123456789D )
        DecimalToSgl_Dbl( Decimal.MinValue )
        DecimalToSgl_Dbl( Decimal.MaxValue )
    End Sub 
End Module 

' This example of the
'   Decimal.ToSingle( Decimal ) and
'   Decimal.ToDouble( Decimal )
' methods generates the following output. It
' displays several converted Decimal values.
' 
'               Decimal argument           Single                 Double
'               ----------------           ------                 ------
' 0.0000000000000000000000000001            1E-28                  1E-28
' 0.0000000000112233445566778899     1.122334E-11   1.12233445566779E-11
'                            123              123                    123
'                     123.000000              123                    123
'            123456789.123456789     1.234568E+08       123456789.123457
'    123456789123456789123456789     1.234568E+26   1.23456789123457E+26
' -79228162514264337593543950335    -7.922816E+28  -7.92281625142643E+28
'  79228162514264337593543950335     7.922816E+28   7.92281625142643E+28

Comentarios

Esta operación puede producir errores de redondeo porque un número de punto flotante de precisión doble tiene menos dígitos significativos que un Decimal.This operation can produce round-off errors because a double-precision floating-point number has fewer significant digits than a Decimal.

También puede convertir un Decimal objeto en un Double valor mediante el operador de Explicit asignación.You can also convert a Decimal to a Double value by using the Explicit assignment operator. Dado que la conversión puede implicar una pérdida de precisión, debe utilizar un operador de C# conversión en o una función de conversión en Visual Basic.Because the conversion can entail a loss of precision, you must use a casting operator in C# or a conversion function in Visual Basic.

Se aplica a

Consulte también: