Convert.ToDouble Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Convertit une valeur spécifiée en nombre à virgule flottante double précision.

Surcharges

ToDouble(Object, IFormatProvider)	Convertit la valeur de l'objet spécifié en nombre à virgule flottante double précision à l'aide des informations de mise en forme spécifiées propres à la culture.
ToDouble(UInt64)	Convertit la valeur de l'entier non signé 64 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(UInt32)	Convertit la valeur de l'entier non signé 32 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(UInt16)	Convertit la valeur de l'entier non signé 16 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(String, IFormatProvider)	Convertit la représentation sous forme de chaîne spécifiée d'un nombre en nombre à virgule flottante double précision équivalent à l'aide des informations de mise en forme spécifiées propres à la culture.
ToDouble(Single)	Convertit la valeur du nombre à virgule flottante simple précision spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(SByte)	Convertit la valeur de l'entier signé 8 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(Object)	Convertit la valeur de l'objet spécifié en nombre à virgule flottante double précision.
ToDouble(String)	Convertit la représentation sous forme de chaîne spécifiée d'un nombre en nombre à virgule flottante double précision équivalent.
ToDouble(Int32)	Convertit la valeur de l'entier signé 32 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(Int16)	Convertit la valeur de l'entier signé 16 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(Double)	Retourne le nombre à virgule flottante double précision spécifié. Aucune conversion n'est effectuée.
ToDouble(Decimal)	Convertit la valeur du nombre décimal spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(DateTime)	L'appel de cette méthode lève toujours InvalidCastException.
ToDouble(Char)	L'appel de cette méthode lève toujours InvalidCastException.
ToDouble(Byte)	Convertit la valeur de l'entier non signé 8 bits spécifié en nombre à virgule flottante double précision équivalent.
ToDouble(Boolean)	Convertit la valeur booléenne spécifiée en nombre à virgule flottante double précision équivalent.
ToDouble(Int64)	Convertit la valeur de l'entier signé 64 bits spécifié en nombre à virgule flottante double précision équivalent.

ToDouble(Object, IFormatProvider)

Source:

Convert.cs

Convertit la valeur de l'objet spécifié en nombre à virgule flottante double précision à l'aide des informations de mise en forme spécifiées propres à la culture.

C#

public static double ToDouble (object? value, IFormatProvider? provider);

Paramètres

value

Object

Objet qui implémente l'interface IConvertible.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

Retours

Double

Nombre à virgule flottante double précision qui est équivalent à value, ou zéro si value est null.

Exceptions

FormatException

value n’a pas un format approprié pour un type Double.

InvalidCastException

value n’implémente pas l’interface IConvertible .

OverflowException

value représente un nombre inférieur à Double.MinValue ou supérieur à Double.MaxValue.

Exemples

L’exemple suivant définit une classe qui implémente IConvertible et une classe qui implémente IFormatProvider. Les objets de la classe qui implémente IConvertible contiennent un tableau de Double valeurs. Un objet de chaque classe est passé à la ToDouble méthode . Cette méthode retourne une moyenne du tableau de valeurs, à l’aide de Double l’objet qui implémente IFormatProvider pour déterminer comment calculer la moyenne.

C#

using System;
using System.Collections;

// Define the types of averaging available in the class
// implementing IConvertible.
public enum AverageType : short
{
    None = 0,
    GeometricMean = 1,
    ArithmeticMean = 2,
    Median = 3
};

// Pass an instance of this class to methods that require an
// IFormatProvider. The class instance determines the type of
// average to calculate.
public class AverageInfo : IFormatProvider
{
    protected AverageType AvgType;

    // Specify the type of averaging in the constructor.
    public AverageInfo( AverageType avgType )
    {
        this.AvgType = avgType;
    }

    // This method returns a reference to the containing object
    // if an object of AverageInfo type is requested.
    public object GetFormat( Type argType )
    {
        if ( argType == typeof( AverageInfo ) )
            return this;
        else
            return null;
    }

    // Use this property to set or get the type of averaging.
    public AverageType TypeOfAverage
    {
        get { return this.AvgType; }
        set { this.AvgType = value; }
    }
}

// This class encapsulates an array of double values and implements
// the IConvertible interface. Most of the IConvertible methods
// return an average of the array elements in one of three types:
// arithmetic mean, geometric mean, or median.
public class DataSet : IConvertible
{
    protected ArrayList     data;
    protected AverageInfo   defaultProvider;

    // Construct the object and add an initial list of values.
    // Create a default format provider.
    public DataSet( params double[ ] values )
    {
        data = new ArrayList( values );
        defaultProvider =
            new AverageInfo( AverageType.ArithmeticMean );
    }

    // Add additional values with this method.
    public int Add( double value )
    {
        data.Add( value );
        return data.Count;
    }

    // Get, set, and add values with this indexer property.
    public double this[ int index ]
    {
        get
        {
            if( index >= 0 && index < data.Count )
                return (double)data[ index ];
            else
                throw new InvalidOperationException(
                    "[DataSet.get] Index out of range." );
        }
        set
        {
            if( index >= 0 && index < data.Count )
                data[ index ] = value;

            else if( index == data.Count )
                data.Add( value );
            else
                throw new InvalidOperationException(
                    "[DataSet.set] Index out of range." );
        }
    }

    // This property returns the number of elements in the object.
    public int Count
    {
        get { return data.Count; }
    }

    // This method calculates the average of the object's elements.
    protected double Average( AverageType avgType )
    {
        double  SumProd;

        if( data.Count == 0 )
            return 0.0;

        switch( avgType )
        {
            case AverageType.GeometricMean:

                SumProd = 1.0;
                for( int Index = 0; Index < data.Count; Index++ )
                    SumProd *= (double)data[ Index ];

                // This calculation will not fail with negative
                // elements.
                return Math.Sign( SumProd ) * Math.Pow(
                    Math.Abs( SumProd ), 1.0 / data.Count );

            case AverageType.ArithmeticMean:

                SumProd = 0.0;
                for( int Index = 0; Index < data.Count; Index++ )
                    SumProd += (double)data[ Index ];

                return SumProd / data.Count;

            case AverageType.Median:

                if( data.Count % 2 == 0 )
                    return ( (double)data[ data.Count / 2 ] +
                        (double)data[ data.Count / 2 - 1 ] ) / 2.0;
                else
                    return (double)data[ data.Count / 2 ];

            default:
                return 0.0;
        }
    }

    // Get the AverageInfo object from the caller's format provider,
    // or use the local default.
    protected AverageInfo GetAverageInfo( IFormatProvider provider )
    {
        AverageInfo avgInfo = null;

        if( provider != null )
            avgInfo = (AverageInfo)provider.GetFormat(
                typeof( AverageInfo ) );

        if ( avgInfo == null )
            return defaultProvider;
        else
            return avgInfo;
    }

    // Calculate the average and limit the range.
    protected double CalcNLimitAverage( double min, double max,
        IFormatProvider provider )
    {
        // Get the format provider and calculate the average.
        AverageInfo avgInfo = GetAverageInfo( provider );
        double avg = Average( avgInfo.TypeOfAverage );

        // Limit the range, based on the minimum and maximum values
        // for the type.
        return avg > max ? max : avg < min ? min : avg;
    }

    // The following elements are required by IConvertible.

    // None of these conversion functions throw exceptions. When
    // the data is out of range for the type, the appropriate
    // MinValue or MaxValue is used.
    public TypeCode GetTypeCode( )
    {
        return TypeCode.Object;
    }

    public bool ToBoolean( IFormatProvider provider )
    {
        // ToBoolean is false if the dataset is empty.
        if( data.Count <= 0 )
        {
            return false;
        }

        // For median averaging, ToBoolean is true if any
        // non-discarded elements are nonzero.
        else if( AverageType.Median ==
            GetAverageInfo( provider ).TypeOfAverage )
        {
            if (data.Count % 2 == 0 )
                return ( (double)data[ data.Count / 2 ] != 0.0 ||
                    (double)data[ data.Count / 2 - 1 ] != 0.0 );
            else
                return (double)data[ data.Count / 2 ] != 0.0;
        }

        // For arithmetic or geometric mean averaging, ToBoolean is
        // true if any element of the dataset is nonzero.
        else
        {
            for( int Index = 0; Index < data.Count; Index++ )
                if( (double)data[ Index ] != 0.0 )
                    return true;
            return false;
        }
    }

    public byte ToByte( IFormatProvider provider )
    {
        return Convert.ToByte( CalcNLimitAverage(
            Byte.MinValue, Byte.MaxValue, provider ) );
    }

    public char ToChar( IFormatProvider provider )
    {
        return Convert.ToChar( Convert.ToUInt16( CalcNLimitAverage(
            Char.MinValue, Char.MaxValue, provider ) ) );
    }

    // Convert to DateTime by adding the calculated average as
    // seconds to the current date and time. A valid DateTime is
    // always returned.
    public DateTime ToDateTime( IFormatProvider provider )
    {
        double seconds =
            Average( GetAverageInfo( provider ).TypeOfAverage );
        try
        {
            return DateTime.Now.AddSeconds( seconds );
        }
        catch( ArgumentOutOfRangeException )
        {
            return seconds < 0.0 ? DateTime.MinValue : DateTime.MaxValue;
        }
    }

    public decimal ToDecimal( IFormatProvider provider )
    {
        // The Double conversion rounds Decimal.MinValue and
        // Decimal.MaxValue to invalid Decimal values, so the
        // following limits must be used.
        return Convert.ToDecimal( CalcNLimitAverage(
            -79228162514264330000000000000.0,
            79228162514264330000000000000.0, provider ) );
    }

    public double ToDouble( IFormatProvider provider )
    {
        return Average( GetAverageInfo(provider).TypeOfAverage );
    }

    public short ToInt16( IFormatProvider provider )
    {
        return Convert.ToInt16( CalcNLimitAverage(
            Int16.MinValue, Int16.MaxValue, provider ) );
    }

    public int ToInt32( IFormatProvider provider )
    {
        return Convert.ToInt32( CalcNLimitAverage(
            Int32.MinValue, Int32.MaxValue, provider ) );
    }

    public long ToInt64( IFormatProvider provider )
    {
        // The Double conversion rounds Int64.MinValue and
        // Int64.MaxValue to invalid Int64 values, so the following
        // limits must be used.
        return Convert.ToInt64( CalcNLimitAverage(
            -9223372036854775000, 9223372036854775000, provider ) );
    }

    public SByte ToSByte( IFormatProvider provider )
    {
        return Convert.ToSByte( CalcNLimitAverage(
            SByte.MinValue, SByte.MaxValue, provider ) );
    }

    public float ToSingle( IFormatProvider provider )
    {
        return Convert.ToSingle( CalcNLimitAverage(
            Single.MinValue, Single.MaxValue, provider ) );
    }

    public UInt16 ToUInt16( IFormatProvider provider )
    {
        return Convert.ToUInt16( CalcNLimitAverage(
            UInt16.MinValue, UInt16.MaxValue, provider ) );
    }

    public UInt32 ToUInt32( IFormatProvider provider )
    {
        return Convert.ToUInt32( CalcNLimitAverage(
            UInt32.MinValue, UInt32.MaxValue, provider ) );
    }

    public UInt64 ToUInt64( IFormatProvider provider )
    {
        // The Double conversion rounds UInt64.MaxValue to an invalid
        // UInt64 value, so the following limit must be used.
        return Convert.ToUInt64( CalcNLimitAverage(
            0, 18446744073709550000.0, provider ) );
    }

    public object ToType( Type conversionType,
        IFormatProvider provider )
    {
        return Convert.ChangeType( Average(
            GetAverageInfo( provider ).TypeOfAverage ),
            conversionType );
    }

    public string ToString( IFormatProvider provider )
    {
        AverageType avgType = GetAverageInfo( provider ).TypeOfAverage;
        return String.Format( "( {0}: {1:G10} )", avgType,
            Average( avgType ) );
    }
}

class IConvertibleProviderDemo
{
    // Display a DataSet with three different format providers.
    public static void DisplayDataSet( DataSet ds )
    {
        string      fmt    = "{0,-12}{1,20}{2,20}{3,20}";
        AverageInfo median = new AverageInfo( AverageType.Median );
        AverageInfo geMean =
            new AverageInfo( AverageType.GeometricMean );

         // Display the dataset elements.
        if( ds.Count > 0 )
        {
            Console.Write( "\nDataSet: [{0}", ds[ 0 ] );
            for( int iX = 1; iX < ds.Count; iX++ )
                Console.Write( ", {0}", ds[ iX ] );
            Console.WriteLine( "]\n" );
        }

        Console.WriteLine( fmt, "Convert.", "Default",
            "Geometric Mean", "Median");
        Console.WriteLine( fmt, "--------", "-------",
            "--------------", "------");
        Console.WriteLine( fmt, "ToBoolean",
            Convert.ToBoolean( ds, null ),
            Convert.ToBoolean( ds, geMean ),
            Convert.ToBoolean( ds, median ) );
        Console.WriteLine( fmt, "ToByte",
            Convert.ToByte( ds, null ),
            Convert.ToByte( ds, geMean ),
            Convert.ToByte( ds, median ) );
        Console.WriteLine( fmt, "ToChar",
            Convert.ToChar( ds, null ),
            Convert.ToChar( ds, geMean ),
            Convert.ToChar( ds, median ) );
        Console.WriteLine( "{0,-12}{1,20:yyyy-MM-dd HH:mm:ss}" +
            "{2,20:yyyy-MM-dd HH:mm:ss}{3,20:yyyy-MM-dd HH:mm:ss}",
            "ToDateTime", Convert.ToDateTime( ds, null ),
            Convert.ToDateTime( ds, geMean ),
            Convert.ToDateTime( ds, median ) );
        Console.WriteLine( fmt, "ToDecimal",
            Convert.ToDecimal( ds, null ),
            Convert.ToDecimal( ds, geMean ),
            Convert.ToDecimal( ds, median ) );
        Console.WriteLine( fmt, "ToDouble",
            Convert.ToDouble( ds, null ),
            Convert.ToDouble( ds, geMean ),
            Convert.ToDouble( ds, median ) );
        Console.WriteLine( fmt, "ToInt16",
            Convert.ToInt16( ds, null ),
            Convert.ToInt16( ds, geMean ),
            Convert.ToInt16( ds, median ) );
        Console.WriteLine( fmt, "ToInt32",
            Convert.ToInt32( ds, null ),
            Convert.ToInt32( ds, geMean ),
            Convert.ToInt32( ds, median ) );
        Console.WriteLine( fmt, "ToInt64",
            Convert.ToInt64( ds, null ),
            Convert.ToInt64( ds, geMean ),
            Convert.ToInt64( ds, median ) );
        Console.WriteLine( fmt, "ToSByte",
            Convert.ToSByte( ds, null ),
            Convert.ToSByte( ds, geMean ),
            Convert.ToSByte( ds, median ) );
        Console.WriteLine( fmt, "ToSingle",
            Convert.ToSingle( ds, null ),
            Convert.ToSingle( ds, geMean ),
            Convert.ToSingle( ds, median ) );
        Console.WriteLine( fmt, "ToUInt16",
            Convert.ToUInt16( ds, null ),
            Convert.ToUInt16( ds, geMean ),
            Convert.ToUInt16( ds, median ) );
        Console.WriteLine( fmt, "ToUInt32",
            Convert.ToUInt32( ds, null ),
            Convert.ToUInt32( ds, geMean ),
            Convert.ToUInt32( ds, median ) );
        Console.WriteLine( fmt, "ToUInt64",
            Convert.ToUInt64( ds, null ),
            Convert.ToUInt64( ds, geMean ),
            Convert.ToUInt64( ds, median ) );
    }

    public static void Main( )
    {
        Console.WriteLine( "This example of " +
            "the Convert.To<Type>( object, IFormatProvider ) methods " +
            "\ngenerates the following output. The example " +
            "displays the values \nreturned by the methods, " +
            "using several IFormatProvider objects.\n" );

        DataSet ds1 = new DataSet(
            10.5, 22.2, 45.9, 88.7, 156.05, 297.6 );
        DisplayDataSet( ds1 );

        DataSet ds2 = new DataSet(
            359999.95, 425000, 499999.5, 775000, 1695000 );
        DisplayDataSet( ds2 );
    }
}

/*
This example of the Convert.To<Type>( object, IFormatProvider ) methods
generates the following output. The example displays the values
returned by the methods, using several IFormatProvider objects.

DataSet: [10.5, 22.2, 45.9, 88.7, 156.05, 297.6]

Convert.                 Default      Geometric Mean              Median
--------                 -------      --------------              ------
ToBoolean                   True                True                True
ToByte                       103                  59                  67
ToChar                         g                   ;                   C
ToDateTime   2003-05-13 15:04:12 2003-05-13 15:03:28 2003-05-13 15:03:35
ToDecimal       103.491666666667    59.4332135445164                67.3
ToDouble        103.491666666667    59.4332135445164                67.3
ToInt16                      103                  59                  67
ToInt32                      103                  59                  67
ToInt64                      103                  59                  67
ToSByte                      103                  59                  67
ToSingle                103.4917            59.43321                67.3
ToUInt16                     103                  59                  67
ToUInt32                     103                  59                  67
ToUInt64                     103                  59                  67

DataSet: [359999.95, 425000, 499999.5, 775000, 1695000]

Convert.                 Default      Geometric Mean              Median
--------                 -------      --------------              ------
ToBoolean                   True                True                True
ToByte                       255                 255                 255
ToChar                         ?                   ?                   ?
ToDateTime   2003-05-22 07:39:08 2003-05-20 22:28:45 2003-05-19 09:55:48
ToDecimal              750999.89    631577.237188435            499999.5
ToDouble               750999.89    631577.237188435            499999.5
ToInt16                    32767               32767               32767
ToInt32                   751000              631577              500000
ToInt64                   751000              631577              500000
ToSByte                      127                 127                 127
ToSingle                750999.9            631577.3            499999.5
ToUInt16                   65535               65535               65535
ToUInt32                  751000              631577              500000
ToUInt64                  751000              631577              500000
*/

Remarques

La valeur de retour est le résultat de l’appel de la IConvertible.ToDouble méthode du type sous-jacent de value.

provider permet à l’utilisateur de spécifier des informations de conversion spécifiques à la culture sur le contenu de value. Par exemple, si value est un String qui représente un nombre, provider peut fournir des informations spécifiques à la culture sur la notation utilisée pour représenter ce nombre.

Les types de base ignorent provider; toutefois, le paramètre peut être utilisé si value est un type défini par l’utilisateur qui implémente l’interface IConvertible .

ToDouble(UInt64)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 64 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

[System.CLSCompliant(false)]
public static double ToDouble (ulong value);

Paramètres

value

UInt64

Entier non signé 64 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit chaque élément d’un tableau de UInt64 valeurs en valeur Double .

C#

ulong[] numbers = { UInt64.MinValue, 121, 12345, UInt64.MaxValue };
double result;

foreach (ulong number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the UInt64 value {0} to {1}.",
                     number, result);
}
// The example displays the following output:
//    Converted the UInt64 value 0 to 0.
//    Converted the UInt64 value 121 to 121.
//    Converted the UInt64 value 12345 to 12345.
//    Converted the UInt64 value 18446744073709551615 to 1.84467440737096E+19.

ToDouble(UInt32)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 32 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

[System.CLSCompliant(false)]
public static double ToDouble (uint value);

Paramètres

value

UInt32

Entier non signé 32 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit chaque élément d’un tableau de UInt32 valeurs en valeur Double .

C#

uint[] numbers = { UInt32.MinValue, 121, 12345, UInt32.MaxValue };
double result;

foreach (uint number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the UInt32 value {0} to {1}.",
                     number, result);
}
// The example displays the following output:
//       Converted the UInt32 value 0 to 0.
//       Converted the UInt32 value 121 to 121.
//       Converted the UInt32 value 12345 to 12345.
//       Converted the UInt32 value 4294967295 to 4294967295.

ToDouble(UInt16)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 16 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

[System.CLSCompliant(false)]
public static double ToDouble (ushort value);

Paramètres

value

UInt16

Entier non signé 16 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit chaque élément d’un tableau de UInt16 valeurs en valeur Double .

C#

ushort[] numbers = { UInt16.MinValue, 121, 12345, UInt16.MaxValue };
double result;

foreach (ushort number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the UInt16 value {0} to {1}.",
                     number, result);
}
// The example displays the following output:
//       Converted the UInt16 value 0 to 0.
//       Converted the UInt16 value 121 to 121.
//       Converted the UInt16 value 12345 to 12345.
//       Converted the UInt16 value 65535 to 65535.

ToDouble(String, IFormatProvider)

Source:

Convert.cs

Convertit la représentation sous forme de chaîne spécifiée d'un nombre en nombre à virgule flottante double précision équivalent à l'aide des informations de mise en forme spécifiées propres à la culture.

C#

public static double ToDouble (string? value, IFormatProvider? provider);

Paramètres

value

String

Chaîne contenant le nombre à convertir.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

Retours

Double

Nombre à virgule flottante double précision qui est équivalent au nombre dans value, ou 0 (zéro) si value est null.

Exceptions

FormatException

value n’est pas un nombre exprimé dans un format valide.

OverflowException

value représente un nombre inférieur à Double.MinValue ou supérieur à Double.MaxValue.

Exemples

L’exemple suivant convertit des représentations sous forme de chaîne de Double valeurs avec la méthode, à l’aide ToDouble d’un IFormatProvider objet .

C#

using System;
using System.Globalization;

class Example
{
    static void Main()
    {
        // Create a NumberFormatInfo object and set some of its properties.
        NumberFormatInfo provider = new NumberFormatInfo();
        provider.NumberDecimalSeparator = ",";
        provider.NumberGroupSeparator = ".";
        provider.NumberGroupSizes = new int[] { 3 };

        // Define an array of numeric strings to convert.
        String[] values = { "123456789", "12345.6789", "12345,6789",
                            "123,456.789", "123.456,789",
                            "123,456,789.0123", "123.456.789,0123" };

        Console.WriteLine("Default Culture: {0}\n",
                          CultureInfo.CurrentCulture.Name);
        Console.WriteLine("{0,-22} {1,-20} {2,-20}\n", "String to Convert",
                          "Default/Exception", "Provider/Exception");

        // Convert each string to a Double with and without the provider.
        foreach (var value in values) {
           Console.Write("{0,-22} ", value);
           try {
              Console.Write("{0,-20} ", Convert.ToDouble(value));
           }
           catch (FormatException e) {
              Console.Write("{0,-20} ", e.GetType().Name);
           }
           try {
              Console.WriteLine("{0,-20} ", Convert.ToDouble(value, provider));
           }
           catch (FormatException e) {
              Console.WriteLine("{0,-20} ", e.GetType().Name);
           }
        }
    }
}
// The example displays the following output:
//       Default Culture: en-US
//
//       String to Convert      Default/Exception    Provider/Exception
//
//       123456789              123456789            123456789
//       12345.6789             12345.6789           123456789
//       12345,6789             123456789            12345.6789
//       123,456.789            123456.789           FormatException
//       123.456,789            FormatException      123456.789
//       123,456,789.0123       123456789.0123       FormatException
//       123.456.789,0123       FormatException      123456789.0123

Remarques

La valeur de retour est le résultat de l’appel de la Double.Parse méthode sur value.

providerest un IFormatProvider instance qui obtient un NumberFormatInfo objet. L’objet NumberFormatInfo fournit des informations spécifiques à la culture sur le format de value. Si provider est null, le NumberFormatInfo pour la culture actuelle est utilisé.

Si vous préférez ne pas gérer d’exception si la conversion échoue, vous pouvez appeler la méthode à la Double.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.

ToDouble(Single)

Source:

Convert.cs

Convertit la valeur du nombre à virgule flottante simple précision spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (float value);

Paramètres

value

Single

Nombre à virgule flottante simple précision.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit une Single valeur en Double valeur.

C#

public void CovertDoubleFloat(double doubleVal) {	
    float floatVal = 0;

    // Double to float conversion cannot overflow.
        floatVal = System.Convert.ToSingle(doubleVal);
        System.Console.WriteLine("{0} as a float is {1}",
            doubleVal, floatVal);

    // Conversion from float to double cannot overflow.
    doubleVal = System.Convert.ToDouble(floatVal);
    System.Console.WriteLine("{0} as a double is: {1}",
        floatVal, doubleVal);
}

Voir aussi

• Single

ToDouble(SByte)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier signé 8 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

[System.CLSCompliant(false)]
public static double ToDouble (sbyte value);

Paramètres

value

SByte

Entier signé 8 bits à convertir.

Retours

Double

Entier signé 8 bits équivalent à value.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit chaque élément d’un tableau de SByte valeurs en valeur Double .

C#

sbyte[] numbers = { SByte.MinValue, -23, 0, 17, SByte.MaxValue };
double result;

foreach (sbyte number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the SByte value {0} to {1}.", number, result);
}
//       Converted the SByte value -128 to -128.
//       Converted the SByte value -23 to -23.
//       Converted the SByte value 0 to 0.
//       Converted the SByte value 17 to 17.
//       Converted the SByte value 127 to 127.

ToDouble(Object)

Source:

Convert.cs

Convertit la valeur de l'objet spécifié en nombre à virgule flottante double précision.

C#

public static double ToDouble (object? value);

Paramètres

value

Object

Objet qui implémente l'interface IConvertible ou null.

Retours

Double

Nombre à virgule flottante double précision qui est équivalent à value, ou zéro si value est null.

Exceptions

FormatException

value n’a pas un format approprié pour un type Double.

InvalidCastException

value n’implémente pas l’interface IConvertible .

- ou -

La conversion n’est pas prise en charge.

OverflowException

value représente un nombre inférieur à Double.MinValue ou supérieur à Double.MaxValue.

Exemples

L’exemple suivant tente de convertir chaque valeur d’un tableau d’objets en .Double

C#

object[] values = { true, 'a', 123, 1.764e32f, "9.78", "1e-02",
                    1.67e03f, "A100", "1,033.67", DateTime.Now,
                    Decimal.MaxValue };
double result;

foreach (object value in values)
{
   try {
      result = Convert.ToDouble(value);
      Console.WriteLine("Converted the {0} value {1} to {2}.",
                        value.GetType().Name, value, result);
   }
   catch (FormatException) {
      Console.WriteLine("The {0} value {1} is not recognized as a valid Double value.",
                        value.GetType().Name, value);
   }
   catch (InvalidCastException) {
      Console.WriteLine("Conversion of the {0} value {1} to a Double is not supported.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Converted the Boolean value True to 1.
//    Conversion of the Char value a to a Double is not supported.
//    Converted the Int32 value 123 to 123.
//    Converted the Single value 1.764E+32 to 1.76399995098587E+32.
//    Converted the String value 9.78 to 9.78.
//    Converted the String value 1e-02 to 0.01.
//    Converted the Single value 1670 to 1670.
//    The String value A100 is not recognized as a valid Double value.
//    Converted the String value 1,033.67 to 1033.67.
//    Conversion of the DateTime value 10/21/2008 07:12:12 AM to a Double is not supported.
//    Converted the Decimal value 79228162514264337593543950335 to 7.92281625142643E+28.

Remarques

Si value n’est pas null, cette méthode encapsule un appel à l’implémentation IConvertible.ToDouble du type sous-jacent de value.

ToDouble(String)

Source:

Convert.cs

Convertit la représentation sous forme de chaîne spécifiée d'un nombre en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (string? value);

Paramètres

value

String

Chaîne contenant le nombre à convertir.

Retours

Double

Nombre à virgule flottante double précision qui est équivalent au nombre dans value, ou 0 (zéro) si value est null.

Exceptions

FormatException

value n’est pas un nombre exprimé dans un format valide.

OverflowException

value représente un nombre inférieur à Double.MinValue ou supérieur à Double.MaxValue.

Exemples

L’exemple suivant tente de convertir chaque élément d’un tableau de chaînes numériques en .Double La sortie de l’exemple provient d’un système dont la culture actuelle est en-US.

C#

using System;

public class Example
{
   public static void Main()
   {
      string[] values= { "-1,035.77219", "1AFF", "1e-35",
                         "1,635,592,999,999,999,999,999,999", "-17.455",
                         "190.34001", "1.29e325"};
      double result;

      foreach (string value in values)
      {
         try {
            result = Convert.ToDouble(value);
            Console.WriteLine("Converted '{0}' to {1}.", value, result);
         }
         catch (FormatException) {
            Console.WriteLine("Unable to convert '{0}' to a Double.", value);
         }
         catch (OverflowException) {
            Console.WriteLine("'{0}' is outside the range of a Double.", value);
         }
      }
   }
}
// The example displays the following output:
//       Converted '-1,035.77219' to -1035.77219.
//       Unable to convert '1AFF' to a Double.
//       Converted '1e-35' to 1E-35.
//       Converted '1,635,592,999,999,999,999,999,999' to 1.635593E+24.
//       Converted '-17.455' to -17.455.
//       Converted '190.34001' to 190.34001.
//       '1.29e325' is outside the range of a Double.

Remarques

L’utilisation de la ToDouble(String) méthode équivaut à passer value à la Double.Parse(String) méthode . value est interprété à l’aide des conventions de mise en forme de la culture actuelle.

Si vous préférez ne pas gérer d’exception si la conversion échoue, vous pouvez appeler la méthode à la Double.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.

ToDouble(Int32)

Source:

Convert.cs

Convertit la valeur de l'entier signé 32 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (int value);

Paramètres

value

Int32

Entier signé 32 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit une Int32 valeur en Double valeur.

C#

public void ConvertDoubleInt(double doubleVal) {
    
    int     intVal = 0;
    // Double to int conversion can overflow.
    try {
        intVal = System.Convert.ToInt32(doubleVal);
        System.Console.WriteLine("{0} as an int is: {1}",
            doubleVal, intVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "Overflow in double-to-int conversion.");
    }

    // Int to double conversion cannot overflow.
    doubleVal = System.Convert.ToDouble(intVal);
    System.Console.WriteLine("{0} as a double is: {1}",
        intVal, doubleVal);
}

ToDouble(Int16)

Source:

Convert.cs

Convertit la valeur de l'entier signé 16 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (short value);

Paramètres

value

Int16

Entier signé 16 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit chaque élément d’un tableau d’entiers signés 16 bits en valeur Double .

C#

short[] numbers = { Int16.MinValue, -1032, 0, 192, Int16.MaxValue };
double result;

foreach (short number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the UInt16 value {0} to {1}.",
                     number, result);
}
//       Converted the UInt16 value -32768 to -32768.
//       Converted the UInt16 value -1032 to -1032.
//       Converted the UInt16 value 0 to 0.
//       Converted the UInt16 value 192 to 192.
//       Converted the UInt16 value 32767 to 32767.

ToDouble(Double)

Source:

Convert.cs

Retourne le nombre à virgule flottante double précision spécifié. Aucune conversion n'est effectuée.

C#

public static double ToDouble (double value);

Paramètres

value

Double

Nombre à virgule flottante double précision à retourner.

Retours

Double

value est retourné sans modification.

Voir aussi

• Double

ToDouble(Decimal)

Source:

Convert.cs

Convertit la valeur du nombre décimal spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (decimal value);

Paramètres

value

Decimal

Nombre décimal à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit une Decimal valeur en Double valeur.

C#

public void ConvertDoubleDecimal(decimal decimalVal){
    
    double doubleVal;
    
    // Decimal to double conversion cannot overflow.
 doubleVal = System.Convert.ToDouble(decimalVal);
    System.Console.WriteLine("{0} as a double is: {1}",
            decimalVal, doubleVal);

    // Conversion from double to decimal can overflow.
    try
 {
       decimalVal = System.Convert.ToDecimal(doubleVal);
    System.Console.WriteLine ("{0} as a decimal is: {1}",
        doubleVal, decimalVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "Overflow in double-to-double conversion.");
    }
}

ToDouble(DateTime)

Source:

Convert.cs

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static double ToDouble (DateTime value);

Paramètres

value

DateTime

Valeur de date et heure à convertir.

Retours

Double

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

ToDouble(Char)

Source:

Convert.cs

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static double ToDouble (char value);

Paramètres

value

Char

Caractère Unicode à convertir.

Retours

Double

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

Voir aussi

• Char

ToDouble(Byte)

Source:

Convert.cs

Convertit la valeur de l'entier non signé 8 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (byte value);

Paramètres

value

Byte

Entier non signé 8 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit une Byte valeur en Double valeur.

C#

public void ConvertDoubleByte(double doubleVal) {
    byte	byteVal = 0;

    // Double to byte conversion can overflow.
    try {
        byteVal = System.Convert.ToByte(doubleVal);
        System.Console.WriteLine("{0} as a byte is: {1}.",
            doubleVal, byteVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "Overflow in double-to-byte conversion.");
    }

    // Byte to double conversion cannot overflow.
    doubleVal = System.Convert.ToDouble(byteVal);
    System.Console.WriteLine("{0} as a double is: {1}.",
        byteVal, doubleVal);
}

ToDouble(Boolean)

Source:

Convert.cs

Convertit la valeur booléenne spécifiée en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (bool value);

Paramètres

value

Boolean

Valeur booléenne à convertir.

Retours

Double

Chiffre 1, si value est true ; sinon, 0.

Exemples

L’exemple suivant convertit une Boolean valeur en Double valeur.

C#

public void ConvertDoubleBool(double doubleVal) {
    bool	boolVal;
    // Double to bool conversion cannot overflow.
    boolVal = System.Convert.ToBoolean(doubleVal);
    System.Console.WriteLine("{0} as a Boolean is: {1}.",
        doubleVal, boolVal);

    // bool to double conversion cannot overflow.
    doubleVal = System.Convert.ToDouble(boolVal);
    System.Console.WriteLine("{0} as a double is: {1}.",
        boolVal, doubleVal);
}

ToDouble(Int64)

Source:

Convert.cs

Convertit la valeur de l'entier signé 64 bits spécifié en nombre à virgule flottante double précision équivalent.

C#

public static double ToDouble (long value);

Paramètres

value

Int64

Entier signé 64 bits à convertir.

Retours

Double

Nombre à virgule flottante double précision équivalent à value.

Exemples

L’exemple suivant convertit chaque élément d’un tableau d’entiers longs signés en valeur Double .

C#

long[] numbers = { Int64.MinValue, -903, 0, 172, Int64.MaxValue};
double result;

foreach (long number in numbers)
{
   result = Convert.ToDouble(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Int64 value '-9223372036854775808' to the Double value -9.22337203685478E+18.
//    Converted the Int64 value '-903' to the Double value -903.
//    Converted the Int64 value '0' to the Double value 0.
//    Converted the Int64 value '172' to the Double value 172.
//    Converted the Int64 value '9223372036854775807' to the Double value 9.22337203685478E+18.