Lire en anglais

Partager via

Double.ToString Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.

Surcharges

ToString()

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.
ToString(IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.
ToString(String)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
ToString(String, IFormatProvider)

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

ToString()

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.

C# 
public override string ToString ();

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance.

Exemples

L’exemple suivant utilise la méthode par défaut Double.ToString() pour afficher les représentations sous forme de chaîne d’un certain nombre de Double valeurs.

C# 
double number;

number = 1.6E20;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());

number = 1.6E2;
// Displays 160.
Console.WriteLine(number.ToString());

number = -3.541;
// Displays -3.541.
Console.WriteLine(number.ToString());

number = -1502345222199E-07;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());

number = -15023452221990199574E-09;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());

number = .60344;
// Displays 0.60344.
Console.WriteLine(number.ToString());

number = .000000001;
// Displays 1E-09.
Console.WriteLine(number.ToString());

L'exemple suivant illustre l'utilisation de ToString.

C# 
bool done = false;
string inp;
do {
   Console.Write("Enter a real number: ");
   inp = Console.ReadLine();
   try {
      d = Double.Parse(inp);
      Console.WriteLine("You entered {0}.", d.ToString());
      done = true;
   }
   catch (FormatException) {
      Console.WriteLine("You did not enter a number.");
   }
   catch (ArgumentNullException) {
      Console.WriteLine("You did not supply any input.");
   }
   catch (OverflowException) {
       Console.WriteLine("The value you entered, {0}, is out of range.", inp);
   }
} while (!done);

Remarques

La ToString() méthode met en forme une Double valeur au format par défaut (« G », ou général) de la culture actuelle. Si vous souhaitez spécifier un format, une précision ou une culture différents, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format Pour la culture Utiliser la surcharge
Format par défaut (« G ») Une culture spécifique ToString(IFormatProvider)
Format ou précision spécifique Culture par défaut (actuelle) ToString(String)
Format ou précision spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolou une chaîne de la forme suivante :

[signe]chiffres intégraux[.[ fractionnaires-chiffres]][E[signe]chiffres exponentiels]

Les éléments facultatifs sont encadrés entre crochets ([ et ]). Les éléments qui contiennent le terme « chiffres » se composent d’une série de caractères numériques compris entre 0 et 9. Les éléments répertoriés dans le tableau suivant sont pris en charge.

Élément Description
sign Signe négatif ou symbole de signe positif.
chiffres intégraux Série de chiffres spécifiant la partie intégrale du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires.
'.' Symbole décimal spécifique à la culture.
fractionnaires-chiffres Série de chiffres spécifiant la partie fractionnaire du nombre.
'E' Caractère majuscule « E », indiquant une notation exponentielle (scientifique).
chiffres exponentiels Série de chiffres spécifiant un exposant.

Voici quelques exemples de la valeur de retour : « 100 », « -123 456 789 », « 123,45E+6 », « 500 », « 3.1416 », « 600 », « -0.123 » et « -Infinity ».

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(IFormatProvider)

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.

C# 
public string ToString (IFormatProvider provider);
C# 
public string ToString (IFormatProvider? provider);

Paramètres

provider
IFormatProvider

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

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, comme indiqué par provider.

Implémente

ToString(IFormatProvider)

Exemples

L’exemple suivant affiche la représentation sous forme de chaîne de deux Double valeurs à l’aide CultureInfo d’objets qui représentent plusieurs cultures différentes.

C# 
double value;

value = -16325.62015;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));

value = 16034.125E21;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

L’exemple suivant illustre l’utilisation de ToString, prenant un String et un IFormatProvider comme paramètres.

C# 
public class Temperature : IFormattable {
    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

Remarques

La ToString(IFormatProvider) méthode met en forme une Double valeur au format par défaut (« G », ou général) d’une culture spécifiée. Si vous souhaitez spécifier un autre format ou culture, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format Pour la culture Utiliser la surcharge
Format par défaut (« G ») Par défaut (actuel) ToString()
Format ou précision spécifique Culture par défaut (actuelle) ToString(String)
Format ou précision spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolou une chaîne de la forme suivante :

[signe]chiffres intégraux[.[ fractionnaires-chiffres]][E[signe]chiffres exponentiels]

Les éléments facultatifs sont encadrés entre crochets ([ et ]). Les éléments qui contiennent le terme « chiffres » se composent d’une série de caractères numériques compris entre 0 et 9. Les éléments répertoriés dans le tableau suivant sont pris en charge.

Élément Description
sign Signe négatif ou symbole de signe positif.
chiffres intégraux Série de chiffres spécifiant la partie intégrale du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires.
'.' Symbole décimal spécifique à la culture.
fractionnaires-chiffres Série de chiffres spécifiant la partie fractionnaire du nombre.
'E' Caractère majuscule « E », indiquant une notation exponentielle (scientifique).
chiffres exponentiels Série de chiffres spécifiant un exposant.

Voici quelques exemples de la valeur de retour : « 100 », « -123 456 789 », « 123,45E+6 », « 500 », « 3.1416 », « 600 », « -0.123 » et « -Infinity ».

Cette instance est mise en forme avec le spécificateur de format numérique général (« G »).

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Le provider paramètre est une IFormatProvider implémentation dont la GetFormat méthode retourne un NumberFormatInfo objet . En règle générale, provider est un CultureInfo objet ou un NumberFormatInfo objet . Le provider paramètre fournit des informations spécifiques à la culture utilisées dans la mise en forme. Si provider a nullla valeur , la valeur de retour est mise en forme à l’aide de l’objet NumberFormatInfo pour la culture actuelle.

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(String)

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

C# 
public string ToString (string format);
C# 
public string ToString (string? format);

Paramètres

format
String

Chaîne de format numérique.

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, comme indiqué par format.

Exceptions

FormatException

format n'est pas valide.

Exemples

L’exemple suivant définit une valeur numérique et la met en forme en tant que valeur monétaire à l’aide de la chaîne de format numérique standard « C » et en tant que valeur numérique à trois décimales à l’aide de la chaîne de format numérique standard « N ». Les chaînes de résultats sont mises en forme à l’aide des conventions de la culture en-US. Pour plus d’informations sur les chaînes de format numérique, consultez Chaînes de format numérique standard et Chaînes de format numérique personnalisées.

C# 
using System;

public class Example
{
   public static void Main()
   {
      float number = 1764.3789m;

      // Format as a currency value.
      Console.WriteLine(number.ToString("C"));

      // Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"));
   }
}
// The example displays the following output:
//       $1,764.38
//       1,764.379

L’exemple suivant affiche plusieurs Double valeurs à l’aide des spécificateurs de format numérique standard pris en charge avec trois chaînes de format numérique personnalisées. L’une de ces chaînes de format personnalisées montre comment pader une Single valeur avec des zéros de début. En outre, l’exemple utilise des spécificateurs de précision avec chaque spécificateur de format standard, à l’exception de « R ». Les valeurs des spécificateurs de précision sont comprises entre 0 et 3. Pour convertir les valeurs numériques en chaînes, l’exemple utilise les conventions de mise en forme de la culture en-US.

C# 
double[] numbers= {1054.32179, -195489100.8377, 1.0437E21,
                   -1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P",
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };
foreach (double number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers) {
      Console.WriteLine("   {0,-22} {1}",
                        specifier + ":", number.ToString(specifier));
      // Add precision specifiers from 0 to 3.
      if (specifier.Length == 1 & ! specifier.Equals("R")) {
         for (int precision = 0; precision <= 3; precision++) {
            string pSpecifier = String.Format("{0}{1}", specifier, precision);
            Console.WriteLine("   {0,-22} {1}",
                              pSpecifier + ":", number.ToString(pSpecifier));
         }
         Console.WriteLine();
      }
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

Remarques

La ToString(String) méthode met en forme une Double valeur dans un format spécifié à l’aide des conventions de la culture actuelle. Si vous souhaitez spécifier un autre format ou culture, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format Pour la culture Utiliser la surcharge
Format par défaut (« G ») Culture par défaut (actuelle) ToString()
Format par défaut (« G ») Une culture spécifique ToString(IFormatProvider)
Format ou précision spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolou la représentation sous forme de chaîne d’un nombre, comme spécifié par format.

Le format paramètre peut être n’importe quel spécificateur de format numérique standard valide, à l’exception de D et X, ainsi que toute combinaison de spécificateurs de format numérique personnalisés. Si format est null ou une chaîne vide, la valeur de retour est mise en forme avec le spécificateur de format numérique général (« G »).

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Par défaut, la valeur de retour contient uniquement 15 chiffres de précision, bien qu’un maximum de 17 chiffres soit conservé en interne. Si la valeur de cette instance est supérieure à 15 chiffres, ToString retourne PositiveInfinitySymbol ou NegativeInfinitySymbol au lieu du nombre attendu. Si vous avez besoin de plus de précision, spécifiez format avec la spécification de format « G17 », qui retourne toujours 17 chiffres de précision, ou « R », qui retourne 15 chiffres si le nombre peut être représenté avec cette précision ou 17 chiffres si le nombre ne peut être représenté qu’avec une précision maximale.

Notes pour les appelants

Dans certains cas, les valeurs Double mises en forme avec la chaîne de format numérique standard "R" ne font pas un aller-retour correct si elles sont compilées avec les commutateurs /platform:x64 ou /platform:anycpu, et exécutées sur des systèmes 64 bits. Pour contourner ce problème, vous pouvez mettre en forme les valeurs Double en utilisant la chaîne de format numérique standard "G17". L'exemple suivant utilise la chaîne de format "R" avec une valeur Double qui ne fait pas un aller-retour correct, et il utilise également la chaîne de format "G17" pour effectuer un aller-retour correct avec la valeur d'origine.

C# 
using System;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Attempting to round-trip a Double with 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R");
      double roundTripped = double.Parse(valueString);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped, initialValue.Equals(roundTripped));

      Console.WriteLine("Attempting to round-trip a Double with 'G17':");
      string valueString17 = initialValue.ToString("G17");
      double roundTripped17 = double.Parse(valueString17);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17));
   }
}
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(String, IFormatProvider)

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

C# 
public string ToString (string format, IFormatProvider provider);
C# 
public string ToString (string? format, IFormatProvider? provider);

Paramètres

format
String

Chaîne de format numérique.

provider
IFormatProvider

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

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, telle que spécifiée par format et provider.

Implémente

ToString(String, IFormatProvider)

Exemples

L’exemple suivant affiche une Double valeur à l’aide de chacun des spécificateurs de format numérique standard pris en charge pour plusieurs cultures différentes.

C# 
double value = 16325.62901;
string specifier;
CultureInfo culture;

// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays:    16325.62901

specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    £16,325.63

specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
 culture = CultureInfo.CreateSpecificCulture("en-NZ");
 Console.WriteLine(value.ToString(specifier, culture));
// Displays:    1.6326E+004

specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325.63

specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16 325,63

specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.256 %

L’exemple suivant illustre l’utilisation de ToString, prenant un String et un IFormatProvider en tant que paramètres.

C# 
public class Temperature : IFormattable {
    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

Remarques

La ToString(String, IFormatProvider) méthode met en forme une Double valeur dans un format spécifié d’une culture spécifiée. Si vous souhaitez spécifier un autre format ou culture, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format Pour la culture Utiliser la surcharge
Format par défaut (« G ») Culture par défaut (actuelle) ToString()
Format par défaut (« G ») Une culture spécifique ToString(IFormatProvider)
Format ou précision spécifique Culture par défaut (actuelle) ToString(String)

La valeur de retour peut être PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolou la représentation sous forme de chaîne d’un nombre, comme spécifié par format.

Le format paramètre peut être n’importe quel spécificateur de format numérique standard valide, à l’exception de D et X, ainsi que toute combinaison de spécificateurs de format numérique personnalisés. Si format est null ou une chaîne vide, la valeur de retour de cette instance est mise en forme avec le spécificateur de format numérique général (« G »).

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Le provider paramètre est une IFormatProvider implémentation dont la GetFormat méthode retourne un NumberFormatInfo objet. En règle générale, provider est un CultureInfo objet ou un NumberFormatInfo objet. Le provider paramètre fournit des informations spécifiques à la culture utilisées dans la mise en forme. Si provider a la valeur null, la valeur de retour est mise en forme à l’aide de l’objet NumberFormatInfo pour la culture actuelle.

Par défaut, la valeur de retour contient uniquement 15 chiffres de précision, bien qu’un maximum de 17 chiffres soit conservé en interne. Si la valeur de cette instance est supérieure à 15 chiffres, ToString retourne PositiveInfinitySymbol ou NegativeInfinitySymbol au lieu du nombre attendu. Si vous avez besoin de plus de précision, spécifiez format avec la spécification de format « G17 », qui retourne toujours 17 chiffres de précision, ou « R », qui retourne 15 chiffres si le nombre peut être représenté avec cette précision ou 17 chiffres si le nombre ne peut être représenté qu’avec une précision maximale.

Notes pour les appelants

Dans certains cas, les valeurs Double mises en forme avec la chaîne de format numérique standard "R" ne font pas un aller-retour correct si elles sont compilées avec les commutateurs /platform:x64 ou /platform:anycpu, et exécutées sur des systèmes 64 bits. Pour contourner ce problème, vous pouvez mettre en forme les valeurs Double en utilisant la chaîne de format numérique standard "G17". L'exemple suivant utilise la chaîne de format "R" avec une valeur Double qui ne fait pas un aller-retour correct, et il utilise également la chaîne de format "G17" pour effectuer un aller-retour correct avec la valeur d'origine.

C# 
using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Attempting to round-trip a Double with 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture);
      double roundTripped = double.Parse(valueString,
                                         CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped, initialValue.Equals(roundTripped));

      Console.WriteLine("Attempting to round-trip a Double with 'G17':");
      string valueString17 = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture);
      double roundTripped17 = double.Parse(valueString17,
                                           CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17));
      // If compiled to an application that targets anycpu or x64 and run on an x64 system,
      // the example displays the following output:
      //       Attempting to round-trip a Double with 'R':
      //       0.6822871999174 = 0.68228719991740006: False
      //
      //       Attempting to round-trip a Double with 'G17':
      //       0.6822871999174 = 0.6822871999174: True
   }
}

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0