Chaînes de format numériques standardStandard Numeric Format Strings

Les chaînes de format numériques standard sont utilisées pour mettre en forme des types numériques courants.Standard numeric format strings are used to format common numeric types. Une chaîne de format numérique standard se présente sous la forme Axx, où :A standard numeric format string takes the form Axx, where:

  • A est un caractère alphabétique unique appelé spécificateur de format.A is a single alphabetic character called the format specifier. Toute chaîne de format numérique contenant plusieurs caractères alphabétiques, y compris un espace blanc, est interprétée comme une chaîne de format numérique personnalisée.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Pour plus d’informations, consultez Chaînes de format numériques personnalisées.For more information, see Custom Numeric Format Strings.

  • xx est un entier facultatif appelé spécificateur de précision.xx is an optional integer called the precision specifier. Le spécificateur de précision est compris entre 0 et 99 ; il affecte le nombre de chiffres dans le résultat.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Notez que le spécificateur de précision contrôle le nombre de chiffres dans la représentation sous forme de chaîne d'un nombre.Note that the precision specifier controls the number of digits in the string representation of a number. Il n'arrondit pas le nombre lui-même.It does not round the number itself. Pour exécuter une opération d'arrondi, utilisez la méthode Math.Ceiling, Math.Floor ou Math.Round.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    Quand le spécificateur de précision contrôle le nombre de chiffres fractionnaires dans la chaîne de résultat, celle-ci reflète un nombre qui est arrondi à un résultat représentable le plus proche du résultat précis à l’infini.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. S’il existe deux résultats représentables aussi proches l’un que l’autre :If there are two equally near representable results:

    • Sur le .NET Framework et .NET Core jusqu’à .NET Core 2.0, le runtime sélectionne le résultat ayant le chiffre le moins significatif le plus élevé (autrement dit, à l’aide de MidpointRounding.AwayFromZero).On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using MidpointRounding.AwayFromZero).
    • Sur .NET Core 2.1 et versions ultérieures, le runtime sélectionne le résultat ayant un chiffre encore moins significatif (autrement dit, à l’aide de MidpointRounding.ToEven).On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Notes

    Le spécificateur de précision détermine le nombre de chiffres dans la chaîne de résultat.The precision specifier determines the number of digits in the result string. Pour remplir une chaîne de résultat avec des espaces de début ou de fin, utilisez la fonctionnalité de mise en forme composite et définissez un composant d’alignement dans l’élément de mise en forme.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Les chaînes de format numériques standard sont prises en charge par :Standard numeric format strings are supported by:

Conseil

Vous pouvez télécharger l’utilitaire de mise en forme, application .NET Core Windows Forms qui vous permet d’appliquer des chaînes de mise en forme à des valeurs numériques ou à des valeurs de date et d’heure, et d’afficher la chaîne de résultat.You can download the Formatting Utility, a .NET Core Windows Forms application that lets you apply format strings to either numeric or date and time values and displays the result string. Le code source est disponible pour C# et Visual Basic.Source code is available for C# and Visual Basic.

Le tableau suivant décrit les spécificateurs de format numériques standard et affiche une sortie produite par chaque spécificateur de format.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Consultez la section Remarques pour plus d’informations sur l’utilisation de chaînes de format numériques standard, et la section Exemple pour obtenir une illustration complète de leur utilisation.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Spécificateur de formatFormat specifier NameName DescriptionDescription ExemplesExamples
"C" ou "c""C" or "c" DeviseCurrency Résultat : une valeur monétaire.Result: A currency value.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre de chiffres décimaux.Precision specifier: Number of decimal digits.

Spécificateur de précision par défaut : défini par NumberFormatInfo.CurrencyDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Plus d’informations : Spécificateur de format monétaire ("C").More information: The Currency ("C") Format Specifier.
123,456 ("C", en-US)-> \$123,46123.456 ("C", en-US) -> \$123.46

123.456 ("C", fr-FR) -> 123,46 €123.456 ("C", fr-FR) -> 123,46 €

123.456 ("C", ja-JP) -> ¥123123.456 ("C", ja-JP) -> ¥123

-123,456 ("C3", en-US)-> (\$123,456)-123.456 ("C3", en-US) -> (\$123.456)

-123.456 ("C3", fr-FR) -> -123,456 €-123.456 ("C3", fr-FR) -> -123,456 €

-123.456 ("C3", ja-JP) -> -¥123.456-123.456 ("C3", ja-JP) -> -¥123.456
"D" ou "d""D" or "d" DecimalDecimal Résultat : chiffres entiers avec un signe négatif facultatif.Result: Integer digits with optional negative sign.

Pris en charge par : les types intégraux uniquement.Supported by: Integral types only.

Spécificateur de précision : nombre minimal de chiffres.Precision specifier: Minimum number of digits.

Spécificateur de précision par défaut : nombre minimal de chiffres requis.Default precision specifier: Minimum number of digits required.

Plus d’informations : Spécificateur de format décimal ("D").More information: The Decimal("D") Format Specifier.
1234 ("D") -> 12341234 ("D") -> 1234

-1234 ("D6") -> -001234-1234 ("D6") -> -001234
"E" ou "e""E" or "e" Exponentiel (scientifique)Exponential (scientific) Résultat : notation exponentielle.Result: Exponential notation.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre de chiffres décimaux.Precision specifier: Number of decimal digits.

Spécificateur de précision par défaut : 6.Default precision specifier: 6.

Plus d’informations : Spécificateur de format exponentiel ("E").More information: The Exponential ("E") Format Specifier.
1052.0329112756 ("E", en-US) -> 1.052033E+0031052.0329112756 ("E", en-US) -> 1.052033E+003

1052.0329112756 ("e", fr-FR) -> 1,052033e+0031052.0329112756 ("e", fr-FR) -> 1,052033e+003

-1052.0329112756 ("e2", en-US) -> -1.05e+003-1052.0329112756 ("e2", en-US) -> -1.05e+003

-1052.0329112756 ("E2", fr-FR) -> -1,05E+003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" ou "f""F" or "f" Virgule fixeFixed-point Résultat : chiffres intégraux et décimaux avec un signe négatif facultatif.Result: Integral and decimal digits with optional negative sign.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre de chiffres décimaux.Precision specifier: Number of decimal digits.

Spécificateur de précision par défaut : défini par NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Plus d’informations : Spécificateur de format à virgule fixe ("F").More information: The Fixed-Point ("F") Format Specifier.
1234.567 ("F", en-US) -> 1234.571234.567 ("F", en-US) -> 1234.57

1234.567 ("F", de-DE) -> 1234,571234.567 ("F", de-DE) -> 1234,57

1234 ("F1", en-US) -> 1234.01234 ("F1", en-US) -> 1234.0

1234 ("F1", de-DE) -> 1234,01234 ("F1", de-DE) -> 1234,0

-1234.56 ("F4", en-US) -> -1234.5600-1234.56 ("F4", en-US) -> -1234.5600

-1234.56 ("F4", de-DE) -> -1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" ou "g""G" or "g" GénéralitésGeneral Résultat : format le plus compact (notation à virgule fixe ou scientifique).Result: The more compact of either fixed-point or scientific notation.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre de chiffres significatifs.Precision specifier: Number of significant digits.

Spécificateur de précision par défaut : dépend du type numérique.Default precision specifier: Depends on numeric type.

Plus d’informations : Spécificateur de format général ("G").More information: The General ("G") Format Specifier.
-123.456 ("G", en-US) -> -123.456-123.456 ("G", en-US) -> -123.456

-123.456 ("G", sv-SE) -> -123,456-123.456 ("G", sv-SE) -> -123,456

123.4546 ("G4", en-US) -> 123.5123.4546 ("G4", en-US) -> 123.5

123.4546 ("G4", sv-SE) -> 123,5123.4546 ("G4", sv-SE) -> 123,5

-1.234567890e-25 ("G", en-US) -> -1.23456789E-25-1.234567890e-25 ("G", en-US) -> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" ou "n""N" or "n" NumberNumber Résultat : chiffres intégraux et décimaux, séparateurs de groupes et séparateur décimal avec un signe négatif facultatif.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre souhaité de décimales.Precision specifier: Desired number of decimal places.

Spécificateur de précision par défaut : défini par NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Plus d’informations : Spécificateur de format numérique ("N").More information: The Numeric ("N") Format Specifier.
1234.567 ("N", en-US) -> 1,234.571234.567 ("N", en-US) -> 1,234.57

1234.567 ("N", ru-RU) -> 1 234,571234.567 ("N", ru-RU) -> 1 234,57

1234 ("N1", en-US) -> 1,234.01234 ("N1", en-US) -> 1,234.0

1234 ("N1", ru-RU) -> 1 234,01234 ("N1", ru-RU) -> 1 234,0

-1234.56 ("N3", en-US) -> -1,234.560-1234.56 ("N3", en-US) -> -1,234.560

-1234.56 ("N3", ru-RU) -> -1 234,560-1234.56 ("N3", ru-RU) -> -1 234,560
"P" ou "p""P" or "p" PercentPercent Résultat : nombre multiplié par 100 et affiché avec un symbole de pourcentage.Result: Number multiplied by 100 and displayed with a percent symbol.

Pris en charge par : tous les types numériquesSupported by: All numeric types.

Spécificateur de précision : nombre souhaité de décimales.Precision specifier: Desired number of decimal places.

Spécificateur de précision par défaut : défini par NumberFormatInfo.PercentDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Plus d’informations : Spécificateur de format pourcentage ("P").More information: The Percent ("P") Format Specifier.
1 ("P", en-US) -> 100.00 %1 ("P", en-US) -> 100.00 %

1 ("P", fr-FR) -> 100,00 %1 ("P", fr-FR) -> 100,00 %

-0.39678 ("P1", en-US) -> -39.7 %-0.39678 ("P1", en-US) -> -39.7 %

-0.39678 ("P1", fr-FR) -> -39,7 %-0.39678 ("P1", fr-FR) -> -39,7 %
"R" ou "r""R" or "r" Aller-retourRound-trip Résultat : chaîne qui peut effectuer un aller-retour vers un nombre identique.Result: A string that can round-trip to an identical number.

Pris en charge par : Single, Double et BigInteger.Supported by: Single, Double, and BigInteger.

Remarque : recommandé pour le type BigInteger uniquement.Note: Recommended for the BigInteger type only. Pour les types Double, utilisez "G17" ; pour les types Single, utilisez "G9".For Double types, use "G17"; for Single types, use "G9".
Spécificateur de précision : Ignoré.Precision specifier: Ignored.

Plus d’informations : Spécificateur de format aller-retour ("R").More information: The Round-trip ("R") Format Specifier.
123456789.12345678 ("R") -> 123456789.12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567-1234567890.12345678 ("R") -> -1234567890.1234567
"X" ou "x""X" or "x" HexadécimalHexadecimal Résultat : chaîne hexadécimale.Result: A hexadecimal string.

Pris en charge par : les types intégraux uniquement.Supported by: Integral types only.

Spécificateur de précision : nombre de chiffres dans la chaîne de résultat.Precision specifier: Number of digits in the result string.

Plus d’informations : Spécificateur de format hexadécimal ("X").More information: The HexaDecimal ("X") Format Specifier.
255 ("X") -> FF255 ("X") -> FF

-1 ("x") -> ff-1 ("x") -> ff

255 ("x4") -> 00ff255 ("x4") -> 00ff

-1 ("X4") -> 00FF-1 ("X4") -> 00FF
N'importe quel caractèreAny other single character Spécificateur inconnuUnknown specifier Résultat : lève un FormatException au moment de l’exécution.Result: Throws a FormatException at run time.

Utilisation de chaînes de format numériques standardUsing Standard Numeric Format Strings

Notes

Les exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Une chaîne de format numérique standard peut être utilisée pour définir la mise en forme d'une valeur numérique de l'une des deux manières suivantes :A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Elle peut être passée à une surcharge de la méthode ToString qui a un paramètre format.It can be passed to an overload of the ToString method that has a format parameter. L'exemple suivant met en forme une valeur numérique en tant que chaîne monétaire dans la culture actuelle (dans le cas présent, la culture en-US).The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))         
    ' Displays $123.46
    
  • Elle peut être fournie comme argument formatString dans un élément de mise en forme utilisé avec des méthodes telles que String.Format, Console.WriteLine et StringBuilder.AppendFormat.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Pour plus d’informations, consultez Mise en forme composite.For more information, see Composite Formatting. L'exemple suivant utilise un élément de mise en forme pour insérer une valeur monétaire dans une chaîne.The following example uses a format item to insert a currency value in a string.

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    decimal value = 123.456m;
    Console.WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    Dim value As Decimal = 123.456d
    Console.WriteLine("Your account balance is {0:C2}.", value)
    ' Displays "Your account balance is $123.46."
    

    Vous pouvez éventuellement fournir un argument alignment pour spécifier la largeur du champ numérique et si sa valeur est alignée à droite ou à gauche.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. L’exemple suivant aligne à gauche une valeur monétaire dans un champ de 28 caractères et aligne à droite une valeur monétaire dans un champ de 14 caractères.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    Dim amounts() As Decimal = { 16305.32d, 18794.16d }
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Il peut être fourni en tant qu’argument formatString dans un élément d’expression interpolée d’une chaîne interpolée.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Pour plus d’informations, consultez la rubrique Interpolation de chaîne dans les informations de référence sur C# ou la rubrique Chaînes interpolées dans les informations de référence sur Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

Les sections suivantes fournissent des informations détaillées sur chacune des chaînes de format numériques standard.The following sections provide detailed information about each of the standard numeric format strings.

Spécificateur de format monétaire ("C")The Currency ("C") Format Specifier

Le spécificateur de format "C" (ou monétaire) convertit un nombre en une chaîne qui représente un montant en devise.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. Le spécificateur de précision indique le nombre souhaité de décimales dans la chaîne de résultat.The precision specifier indicates the desired number of decimal places in the result string. Si le spécificateur de précision est omis, la précision par défaut est définie par la propriété NumberFormatInfo.CurrencyDecimalDigits.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

Si la valeur à mettre en forme contient un nombre de décimales supérieur au nombre spécifié ou au nombre par défaut, la valeur fractionnaire est arrondie dans la chaîne de résultat.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. Si la valeur à droite du nombre de décimales est égale à 5 ou supérieure, le dernier chiffre dans la chaîne de résultat est arrondi à une valeur différente de zéro.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
CurrencyPositivePattern Définit la position du symbole monétaire pour les valeurs positives.Defines the placement of the currency symbol for positive values.
CurrencyNegativePattern Définit la position du symbole monétaire pour les valeurs négatives, et spécifie si le signe négatif est représenté par des parenthèses ou par la propriété NegativeSign.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Définit le signe négatif utilisé si CurrencyNegativePattern indique que les parenthèses ne sont pas utilisées.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Définit le symbole monétaire.Defines the currency symbol.
CurrencyDecimalDigits Définit le nombre par défaut de chiffres décimaux dans une valeur monétaire.Defines the default number of decimal digits in a currency value. Cette valeur peut être substituée à l'aide du spécificateur de précision.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Définit la chaîne qui sépare les groupes de nombres de la partie entière.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Définit le nombre de chiffres entiers qui s'affichent dans un groupe.Defines the number of integer digits that appear in a group.

L'exemple suivant met en forme une valeur Double avec le spécificateur de format monétaire.The following example formats a Double value with the currency format specifier.

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Retour au tableauBack to table

Spécificateur de format décimal ("D")The Decimal ("D") Format Specifier

Le spécificateur de format "D" (ou décimal) convertit un nombre en une chaîne de chiffres décimaux (0-9), préfixée par un signe moins si le nombre est négatif.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Ce format est pris en charge par les types intégraux uniquement.This format is supported only for integral types.

Le spécificateur de précision indique le nombre minimal de chiffres voulu dans la chaîne résultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Le cas échéant, des zéros sont ajoutés à la gauche du nombre afin de fournir le nombre de chiffres déterminé par le spécificateur de précision.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Si aucun spécificateur de précision n'est spécifié, la valeur par défaut est la valeur minimale requise pour représenter l'entier sans zéros non significatifs.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Comme le montre le tableau suivant, une seule propriété affecte la mise en forme de la chaîne de résultat.As the following table shows, a single property affects the formatting of the result string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.

L'exemple suivant met en forme une valeur Int32 avec le spécificateur de format décimal.The following example formats an Int32 value with the decimal format specifier.

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345
int value; 

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer 

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Retour au tableauBack to table

Spécificateur de format exponentiel ("E")The Exponential ("E") Format Specifier

Le spécificateur de format exponentiel ("E") convertit un nombre en une chaîne au format "-d.ddd…E+ddd" ou "-d.ddd…e+ddd", où chaque "d" correspond à un chiffre (0-9).The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). La chaîne commence par un signe moins si le nombre est négatif.The string starts with a minus sign if the number is negative. Un chiffre exactement précède toujours la virgule décimale.Exactly one digit always precedes the decimal point.

Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale.The precision specifier indicates the desired number of digits after the decimal point. Si vous avez omis le spécificateur de précision, une précision par défaut de six chiffres après la virgule décimale est utilisée.If the precision specifier is omitted, a default of six digits after the decimal point is used.

La casse du spécificateur de format indique si le préfixe "E" ou "e" doit être ajouté à l'exposant.The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". L'exposant est toujours constitué d'un signe plus ou moins et d'un minimum de trois chiffres.The exponent always consists of a plus or minus sign and a minimum of three digits. Le cas échéant, des zéros sont ajoutés à l'exposant pour respecter ce minimum.The exponent is padded with zeros to meet this minimum, if required.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif à la fois pour le coefficient et pour l'exposant.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Définit la chaîne qui sépare le chiffre intégral des chiffres décimaux dans le coefficient.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Définit la chaîne qui indique qu'un exposant est positif.Defines the string that indicates that an exponent is positive.

L'exemple suivant met en forme une valeur Double avec le spécificateur de format exponentiel.The following example formats a Double value with the exponential format specifier.

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Retour au tableauBack to table

Spécificateur de format à virgule fixe ("F")The Fixed-Point ("F") Format Specifier

Le spécificateur de format à virgule fixe ("F") convertit un nombre en chaîne au format "-ddd.ddd…" où chaque "d" correspond à un chiffre (0-9).The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). La chaîne commence par un signe moins si le nombre est négatif.The string starts with a minus sign if the number is negative.

Le spécificateur de précision indique le nombre de décimales voulu.The precision specifier indicates the desired number of decimal places. Si le spécificateur de précision est omis, la propriété NumberFormatInfo.NumberDecimalDigits actuelle fournit la précision numérique.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de l'objet NumberFormatInfo qui peuvent contrôler la mise en forme de la chaîne de résultat.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Définit le nombre par défaut de chiffres décimaux.Defines the default number of decimal digits. Cette valeur peut être substituée à l'aide du spécificateur de précision.This value can be overridden by using the precision specifier.

L'exemple suivant met en forme une valeur Double et une valeur Int32 avec le spécificateur de format à virgule fixe.The following example formats a Double and an Int32 value with the fixed-point format specifier.

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F", 
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3", 
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));  
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))  
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _ 
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199                        

Retour au tableauBack to table

Spécificateur de format général ("G")The General ("G") Format Specifier

Le spécificateur de format général (« G ») convertit un nombre dans le format le plus compact (notation à virgule fixe ou notation scientifique), en fonction du type du nombre et de la présence d'un spécificateur de précision.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. Le spécificateur de précision définit le nombre maximal des chiffres significatifs qui peuvent s'afficher dans la chaîne de résultat.The precision specifier defines the maximum number of significant digits that can appear in the result string. Si le spécificateur de précision est omis ou est égal à zéro, le type du nombre détermine la précision par défaut, comme indiqué dans le tableau suivant.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Type numériqueNumeric type Précision par défautDefault precision
Byte ou SByteByte or SByte 3 chiffres3 digits
Int16 ou UInt16Int16 or UInt16 5 chiffres5 digits
Int32 ou UInt32Int32 or UInt32 10 chiffres10 digits
Int64 19 chiffres19 digits
UInt64 20 chiffres20 digits
BigInteger Illimité (identique à "R")Unlimited (same as "R")
Single 7 chiffres7 digits
Double 15 chiffres15 digits
Decimal 29 chiffres29 digits

La notation à virgule fixe est utilisée si l'exposant résultant de l'expression du nombre en notation scientifique est supérieur à -5 et inférieur au spécificateur de précision ; dans le cas contraire, la notation scientifique est utilisée.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. Le résultat contient un séparateur décimal si nécessaire et les zéros non significatifs situés après le séparateur décimal sont omis.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. Si le spécificateur de précision est présent et que le nombre de chiffres significatifs dans le résultat est supérieur à la précision indiquée, les chiffres de fin en trop sont supprimés par arrondi.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

Toutefois, si le nombre est un Decimal et que le spécificateur de précision est omis, la notation à virgule fixe est toujours utilisée et les zéros de fin sont conservés.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

Si la notation scientifique est utilisée, l'exposant du résultat est précédé de "E" si le spécificateur de format est "G", ou de "e" si le spécificateur de format est "g".If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". L'exposant contient au minimum deux chiffres.The exponent contains a minimum of two digits. Cela diffère du format utilisé pour la notation scientifique produite par le spécificateur de format exponentiel, lequel inclut un minimum de trois chiffres dans l'exposant.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Notez que, lorsqu’il est utilisé avec une valeur Double, le spécificateur de format "G17" garantit les allers-retours de la valeur Double originale.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. En effet, Double est un nombre à virgule flottante double précision (binary64) et conforme à la norme IEEE 754-2008, qui offre jusqu’à 17 chiffres de précision.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Nous vous recommandons de l’utiliser à la place du spécificateur de format "R" car, dans certains cas, "R" ne parvient pas à effectuer un aller-retour avec des valeurs à virgule flottante double précision.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. L'exemple suivant illustre cette situation.The following example illustrates one such case.

double original = 0.84551240822557006;
var rSpecifier = original.ToString("R");
var g17Specifier = original.ToString("G17");

var rValue = Double.Parse(rSpecifier);
var g17Value = Double.Parse(g17Specifier);

Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

Lorsqu’il est utilisé avec une valeur Single, le spécificateur de format "G9" garantit les allers-retours de la valeur Single originale.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. En effet, Single est un nombre à virgule flottante simple précision (binary32) et conforme à la norme IEEE 754-2008, qui offre jusqu’à neuf chiffres de précision.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Pour des raisons de performances, nous vous recommandons de l’utiliser à la place du spécificateur de format "R".For performance reasons, we recommend its use instead of the "R" format specifier.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne de résultat.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral digits from decimal digits.
PositiveSign Définit la chaîne qui indique qu'un exposant est positif.Defines the string that indicates that an exponent is positive.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format général.The following example formats assorted floating-point values with the general format specifier.

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416    
double number;

number = 12345.6789;      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06       
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416    
Dim number As Double

number = 12345.6789      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789
                        
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416    

Retour au tableauBack to table

Spécificateur de format numérique ("N")The Numeric ("N") Format Specifier

Le spécificateur de format numérique ("N") convertit un nombre en une chaîne au format "-d,ddd,ddd.ddd…", où "-" correspond, le cas échéant, à un symbole de nombre négatif, "d" indique un chiffre (0-9), "," indique un séparateur de groupes et "." correspond à une virgule décimale.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale.The precision specifier indicates the desired number of digits after the decimal point. Si le spécificateur de précision est omis, le nombre de décimales est défini par la propriété NumberFormatInfo.NumberDecimalDigits actuelle.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne de résultat.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.
NumberNegativePattern Définit le format de valeurs négatives, et spécifie si le signe négatif est représenté par des parenthèses ou par la propriété NegativeSign.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Définit le nombre de chiffres intégraux qui s'affichent entre les séparateurs de groupes.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Définit la chaîne qui sépare les groupes de nombres de la partie entière.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Définit le nombre par défaut de chiffres décimaux.Defines the default number of decimal digits. Cette valeur peut être substituée à l'aide d'un spécificateur de précision.This value can be overridden by using a precision specifier.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format de nombre.The following example formats assorted floating-point values with the number format specifier.

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", 
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0 
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0 

Retour au tableauBack to table

Spécificateur de format pourcentage ("P")The Percent ("P") Format Specifier

Le spécificateur de format pourcentage ("P") multiplie un nombre par 100 et le convertit en une chaîne qui représente un pourcentage.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. Le spécificateur de précision indique le nombre de décimales voulu.The precision specifier indicates the desired number of decimal places. Si le spécificateur de précision est omis, la précision numérique par défaut fournie par la propriété PercentDecimalDigits actuelle est utilisée.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
PercentPositivePattern Définit la position du symbole de pourcentage pour les valeurs positives.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Définit la position du symbole de pourcentage et le symbole négatif pour les valeurs négatives.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.
PercentSymbol Définit le symbole de pourcentage.Defines the percent symbol.
PercentDecimalDigits Définit le nombre par défaut de chiffres décimaux dans une valeur de pourcentage.Defines the default number of decimal digits in a percentage value. Cette valeur peut être substituée à l'aide du spécificateur de précision.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Définit la chaîne qui sépare les groupes de nombres de la partie entière.Defines the string that separates groups of integral numbers.
PercentGroupSizes Définit le nombre de chiffres entiers qui s'affichent dans un groupe.Defines the number of integer digits that appear in a group.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format pourcentage.The following example formats floating-point values with the percent format specifier.

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P", 
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Retour au tableauBack to table

Spécificateur de format aller-retour ("R")The Round-trip ("R") Format Specifier

Le spécificateur de format aller-retour ("R") tente de garantir qu'une valeur numérique qui est convertie en chaîne est de nouveau analysée en aboutissant à la même valeur numérique.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Ce format est pris en charge uniquement pour les types Single, Double et BigInteger.This format is supported only for the Single, Double, and BigInteger types.

Pour les valeurs Double, le spécificateur de format "R" ne parvient pas, dans certains cas, à effectuer un aller-retour de la valeur originale.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. Pour les valeurs Double et Single, il offre également des performances relativement faibles.For both Double and Single values, it also offers relatively poor performance. Nous vous recommandons plutôt d’utiliser le spécificateur de format "G17" pour les valeurs Double, et le spécificateur de format "G9" pour garantir l’aller-retour des valeurs Single.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Lorsqu'une valeur BigInteger est mise en forme à l'aide de ce spécificateur, sa représentation sous forme de chaîne contient tous les chiffres significatifs dans la valeur BigInteger.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Bien que vous puissiez inclure un spécificateur de précision, il est ignoré.Although you can include a precision specifier, it is ignored. Les allers-retours prévalent sur la précision lorsque vous utilisez ce spécificateur.Round trips are given precedence over precision when using this specifier. Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat.The result string is affected by the formatting information of the current NumberFormatInfo object. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne de résultat.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propriété de NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Définit la chaîne qui indique qu'un nombre est négatif.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.Defines the string that separates integral digits from decimal digits.
PositiveSign Définit la chaîne qui indique qu'un exposant est positif.Defines the string that indicates that an exponent is positive.

L'exemple suivant met en forme une valeur BigInteger avec le spécificateur de format aller-retour.The following example formats a BigInteger value with the round-trip format specifier.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   { 
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}                                                                                        // The example displays the following output:
//      85070591730234615847396907784232501249  


Imports System.Numerics

Module Example
   Public Sub Main()
      Dim value = BigInteger.Pow(Int64.MaxValue, 2)
      Console.WriteLine(value.ToString("R"))
   End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249  

Important

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.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Pour plus d'informations, consultez les paragraphes suivants :See the following paragraph for more information.

Pour contourner le problème des valeurs Double mises en forme avec la chaîne de format numérique standard « R » et pour lesquelles l'aller-retour ne fonctionne pas correctement dans le cas d'une compilation avec les indicateurs /platform:x64 ou /platform:anycpu et d'une exécution sur des systèmes 64 bits, vous pouvez mettre en forme ces valeurs Double en utilisant la chaîne de format numérique standard « G17 ».To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. 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.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Console.WriteLine("Attempting to round-trip a Double with 'R':")
      Dim initialValue As Double = 0.6822871999174
      Dim valueString As String = initialValue.ToString("R",
                                               CultureInfo.InvariantCulture)
      Dim roundTripped As Double = Double.Parse(valueString,
                                                CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped, initialValue.Equals(roundTripped))
      Console.WriteLine()
      
      Console.WriteLine("Attempting to round-trip a Double with 'G17':")
      Dim valueString17 As String = initialValue.ToString("G17",
                                                 CultureInfo.InvariantCulture)
      Dim roundTripped17 As Double = double.Parse(valueString17,
                                            CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17))
   End Sub
End Module
' 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

Retour au tableauBack to table

Spécificateur de format hexadécimal ("X")The Hexadecimal ("X") Format Specifier

Le spécificateur de format hexadécimal ("X") convertit un nombre en une chaîne de chiffres hexadécimaux.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. La casse du spécificateur de format indique s'il convient d'utiliser des caractères majuscules ou minuscules pour les chiffres hexadécimaux supérieurs à 9.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Par exemple, utilisez "X" pour produire "ABCDEF" et "x" pour produire "abcdef".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Ce format est pris en charge par les types intégraux uniquement.This format is supported only for integral types.

Le spécificateur de précision indique le nombre minimal de chiffres voulu dans la chaîne résultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Le cas échéant, des zéros sont ajoutés à la gauche du nombre afin de fournir le nombre de chiffres déterminé par le spécificateur de précision.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

Les informations de mise en forme de l'objet NumberFormatInfo actif n'affectent pas la chaîne de résultat.The result string is not affected by the formatting information of the current NumberFormatInfo object.

L'exemple suivant met en forme des valeurs Int32 avec le spécificateur de format hexadécimal.The following example formats Int32 values with the hexadecimal format specifier.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15
int value; 

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer 

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Retour au tableauBack to table

NotesNotes

Paramètres du panneau de configurationControl Panel Settings

Les paramètres de l'élément Options régionales et linguistiques du Panneau de configuration influencent la chaîne résultante produite par une opération de mise en forme.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Ces paramètres sont utilisés pour initialiser l'objet NumberFormatInfo associé à la culture du thread actuel, laquelle fournit les valeurs utilisées pour déterminer la mise en forme.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Les ordinateurs qui utilisent des paramètres différents génèrent des chaînes de résultat différentes.Computers that use different settings generate different result strings.

De plus, si le constructeur CultureInfo.CultureInfo(String) est utilisé pour instancier un nouvel objet CultureInfo qui représente la même culture que la culture système en cours, toutes les personnalisations établies par l’élément Options régionales et linguistiques dans le Panneau de configuration seront appliquées au nouvel objet CultureInfo.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. Vous pouvez utiliser le constructeur CultureInfo.CultureInfo(String, Boolean) pour créer un objet CultureInfo qui ne reflète pas les personnalisations d'un système.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Propriétés NumberFormatInfoNumberFormatInfo Properties

La mise en forme dépend des propriétés de l'objet NumberFormatInfo actuel, qui est fourni implicitement par la culture actuelle du thread ou explicitement par le paramètre IFormatProvider de la méthode qui appelle la mise en forme.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Spécifiez un objet NumberFormatInfo ou CultureInfo pour ce paramètre.Specify a NumberFormatInfo or CultureInfo object for that parameter.

Notes

Pour plus d'informations sur la personnalisation des modèles ou des chaînes utilisés dans la mise en forme des valeurs numériques, consultez la rubrique de la classe NumberFormatInfo.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Types numériques intégraux et à virgule flottanteIntegral and Floating-Point Numeric Types

Certaines descriptions de spécificateurs de format numériques standard font référence à des types numériques intégraux ou à virgule flottante.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Les types numériques intégraux sont Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 et BigInteger.The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Les types numériques à virgule flottante sont Decimal, Single et Double.The floating-point numeric types are Decimal, Single, and Double.

Infinis à virgule flottante et NaNFloating-Point Infinities and NaN

Quelle que soit la chaîne de format, si la valeur d'un type à virgule flottante Single ou Double est l'infini positif, l'infini négatif ou une valeur non numérique (NaN), la chaîne mise en forme est la valeur de la propriété PositiveInfinitySymbol, NegativeInfinitySymbol ou NaNSymbol qui est spécifiée par l'objet NumberFormatInfo actuellement applicable.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

ExempleExample

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

L'exemple suivant met en forme une valeur numérique intégrale et à virgule flottante en utilisant la culture en-US et tous les spécificateurs de format numériques standard.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. Cet exemple utilise deux types numériques particuliers (Double et Int32), mais produirait des résultats similaires pour n'importe lequel des autres types numériques de base (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal et Single).This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and Single).

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}", 
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}", 
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}", 
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"         
Console.WriteLine("G: {0}",  
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}", 
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}", 
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}", 
        floating.ToString("R", ci));           // Displays "R: 10761.937554"            
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}", 
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}", 
        integral.ToString("D6", ci));          // Displays "D: 008395" 
Console.WriteLine("E: {0}", 
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}", 
        integral.ToString("F01", ci));         // Displays "F: 8395.0"    
Console.WriteLine("G: {0}",  
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}", 
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}", 
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}", 
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
   Public Sub Main()
      ' Display string representations of numbers for en-us culture
      Dim ci As New CultureInfo("en-us")
      
      ' Output floating point values
      Dim floating As Double = 10761.937554
      Console.WriteLine("C: {0}", _
              floating.ToString("C", ci))           ' Displays "C: $10,761.94"
      Console.WriteLine("E: {0}", _
              floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
      Console.WriteLine("F: {0}", _
              floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
      Console.WriteLine("G: {0}", _ 
              floating.ToString("G", ci))           ' Displays "G: 10761.937554"
      Console.WriteLine("N: {0}", _
              floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
      Console.WriteLine("P: {0}", _
              (floating/10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
      Console.WriteLine("R: {0}", _
              floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
      Console.WriteLine()
      
      ' Output integral values
      Dim integral As Integer = 8395
      Console.WriteLine("C: {0}", _
              integral.ToString("C", ci))           ' Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", _
              integral.ToString("D6"))              ' Displays "D: 008395" 
      Console.WriteLine("E: {0}", _
              integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
      Console.WriteLine("F: {0}", _
              integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
      Console.WriteLine("G: {0}", _ 
              integral.ToString("G", ci))           ' Displays "G: 8395"
      Console.WriteLine("N: {0}", _
              integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
      Console.WriteLine("P: {0}", _
              (integral/10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", _
              integral.ToString("X", ci))           ' Displays "X: 0x20CB"
      Console.WriteLine()
   End Sub
End Module

Voir aussiSee also