Decimal.ToSingle(Decimal) Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: Decimal.cs

Origine:: Decimal.cs

Origine:: Decimal.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Converte il valore dell'oggetto Decimal specificato nel numero a virgola mobile a precisione singola equivalente.

public:
 static float ToSingle(System::Decimal d);

public static float ToSingle (decimal d);

static member ToSingle : decimal -> single

Public Shared Function ToSingle (d As Decimal) As Single

Parametri

d: Decimal

Numero decimale da convertire.

Restituisce

Single

Numero a virgola mobile a precisione singola equivalente al valore di d.

Esempio

L'esempio di codice seguente converte i Decimal numeri in Single valori usando il ToSingle metodo .

// 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.
open System

let formatter obj1 obj2 obj3 = printfn $"{obj1,30}{obj2,17}{obj3,23}"

// Convert the decimal argument no exceptions are thrown.
let decimalToSgl_Dbl argument =
    // Convert the argument to a float value.
    let singleValue = Decimal.ToSingle argument

    // Convert the argument to a double value.
    let doubleValue = Decimal.ToDouble argument

    formatter argument singleValue doubleValue

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

formatter "decimal argument" "float" "double"
formatter "----------------" "-----" "------"

// Convert decimal values and display the results.
decimalToSgl_Dbl 0.0000000000000000000000000001M
decimalToSgl_Dbl 0.0000000000123456789123456789M
decimalToSgl_Dbl 123M
decimalToSgl_Dbl (Decimal(123000000, 0, 0, false, 6uy))
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

Commenti

Questa operazione può generare errori di arrotondamento perché un numero a virgola mobile a precisione singola ha meno cifre significative di un oggetto Decimal.

È anche possibile convertire un oggetto Decimal in un Single valore usando l'operatore Explicit di assegnazione. Poiché la conversione può comportare una perdita di precisione, è necessario usare un operatore di cast in C# o una funzione di conversione in Visual Basic.

Si applica a

Vedi anche

Single

Condividi tramite