Partager via

Chaînes de format numériques standard

  • Article

Les chaînes de format numériques standard sont utilisées pour mettre en forme des types numériques courants. Une chaîne de format numérique standard se présente sous la forme Axx, où A est un caractère alphabétique appelé spécificateur de format et xx un entier facultatif appelé spécificateur de précision. Le spécificateur de précision est compris entre 0 et 99 ; il affecte le nombre de chiffres dans le résultat. 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. Pour plus d'informations, consultez Chaînes de format numériques personnalisées.

Les chaînes de format numérique standard sont prises en charge par certaines surcharges de la méthode ToString de tous les types numériques. Par exemple, vous pouvez fournir une chaîne de format numérique aux méthodes ToString(String) et ToString(String, IFormatProvider) du type Int32. Les chaînes de format numérique standard sont également prises en charge par la fonctionnalité de mise en forme composite .NET Framework, utilisée par certaines méthodes Write et WriteLine des classes StreamWriter et Console, la méthode String.Format et la méthode StringBuilder.AppendFormat.

ConseilConseil

Vous pouvez télécharger l'application Format Utility (page éventuellement en anglais), qui vous permet d'appliquer des chaînes de format à des valeurs numériques ou de date et d'heure. Elle permet également d'afficher la chaîne de résultat.

Le tableau suivant décrit les spécificateurs de format numériques standard et affiche une sortie produite par chaque spécificateur de format. 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.

Spécificateur de format

Nom

Description

Exemples

"C" ou "c"

Devise

Résultat : une valeur monétaire.

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre de chiffres décimaux.

Spécificateur de précision par défaut : défini par System.Globalization.NumberFormatInfo.

Informations supplémentaires : Spécificateur de format monétaire ("C").

123.456 ("C", en-US) -> $123.46

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

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

-123.456 ("C3", en-US) -> ($123.456)

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

-123.456 ("C3", ja-JP) -> -¥123.456

"D" ou "d"

Decimal

Résultat : chiffres entiers avec un signe négatif facultatif.

Pris en charge par : les types intégraux uniquement.

Spécificateur de précision : nombre minimal de chiffres.

Spécificateur de précision par défaut : nombre minimal de chiffres requis.

Informations supplémentaires : Spécificateur de format décimal ("D").

1234 ("D") -> 1234

-1234 ("D6") -> -001234

"E" ou "e"

Exponentiel (scientifique)

Résultat : notation exponentielle.

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre de chiffres décimaux.

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

Informations supplémentaires : Spécificateur de format exponentiel ("E").

1052.0329112756 ("E", en-US) -> 1.052033E+003

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

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

-1052.0329112756 ("E2", fr_FR) -> -1,05E+003

"F" ou "f"

Virgule fixe

Résultat : chiffres intégraux et décimaux avec un signe négatif facultatif.

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre de chiffres décimaux.

Spécificateur de précision par défaut : défini par System.Globalization.NumberFormatInfo.

Informations supplémentaires : Spécificateur de format à virgule fixe ("F").

1234.567 ("F", en-US) -> 1234.57

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

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

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

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

-1234.56 ("F4", de-DE) -> -1234,5600

"G" ou "g"

Général

Résultat : format le plus compact (notation à virgule fixe ou scientifique).

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre de chiffres significatifs.

Spécificateur de précision par défaut : dépend du type numérique.

Informations supplémentaires : Spécificateur de format standard ("G").

-123.456 ("G", en-US) -> -123.456

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

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

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

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

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25

"N" ou "n"

Nombre

Résultat : chiffres intégraux et décimaux, séparateurs de groupes et séparateur décimal avec un signe négatif facultatif.

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre souhaité de décimales.

Spécificateur de précision par défaut : défini par System.Globalization.NumberFormatInfo.

Informations supplémentaires : Spécificateur de format de nombre ("N").

1234.567 ("N", en-US) -> 1,234.57

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

1234 ("N", en-US) -> 1,234.0

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

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

-1234.56 ("N", ru-RU) -> -1 234,560

"P" ou "p"

Pourcentage

Résultat : nombre multiplié par 100 et affiché avec un symbole de pourcentage.

Pris en charge par : tous les types numériques.

Spécificateur de précision : nombre souhaité de décimales.

Spécificateur de précision par défaut : défini par System.Globalization.NumberFormatInfo.

Informations supplémentaires : Spécificateur de format pourcentage ("P").

1 ("P", en-US) -> 100.00 %

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

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

-0.39678 ("P1", fr-FR) -> -39,7 %

"R" ou "r"

Aller-retour

Résultat : chaîne qui peut effectuer un aller-retour vers un nombre identique.

Pris en charge par : Single, Double et BigInteger.

Spécificateur de précision : ignoré.

Informations supplémentaires : Spécificateur de format aller-retour ("R").

123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567

"X" ou "x"

Hexadécimal

Résultat : chaîne hexadécimale.

Pris en charge par : les types intégraux uniquement.

Spécificateur de précision : nombre de chiffres dans la chaîne de résultat.

Informations supplémentaires : Spécificateur de format hexadécimal ("X").

255 ("X") -> FF

-1 ("x") -> ff

255 ("x4") -> 00ff

-1 ("X4") -> 00FF

N'importe quel caractère

Spécificateur inconnu

Résultat : lève un FormatException au moment de l'exécution.

Utilisation de chaînes de format numériques standard

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 :

  • Elle peut être passée à une surcharge de la méthode ToString qui a un paramètre format. 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).

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))         
' Displays $123.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

  • Elle peut être fournie comme paramètre formatString dans un élément de mise en forme utilisé avec des méthodes telles que String.Format, Console.WriteLine et StringBuilder.AppendFormat. Pour plus d'informations, consultez Mise en forme composite. L'exemple suivant utilise un élément de mise en forme pour insérer une valeur monétaire dans une chaîne.

    Dim value As Decimal = 123.456d
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."

Les sections suivantes fournissent des informations détaillées sur chacune des chaînes de format numériques standard.

Spécificateur de format monétaire ("C")

Le spécificateur de format "C" (ou monétaire) convertit un nombre en une chaîne qui représente un montant en devise. Le spécificateur de précision indique le nombre souhaité de décimales dans la chaîne de résultat. Si le spécificateur de précision est omis, la précision par défaut est définie par la propriété NumberFormatInfo.CurrencyDecimalDigits.

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. 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.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété de NumberFormatInfo

Description

CurrencyPositivePattern

Définit la position du symbole monétaire pour les valeurs positives.

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.

NegativeSign

Définit le signe négatif utilisé si CurrencyNegativePattern indique que les parenthèses ne sont pas utilisées.

CurrencySymbol

Définit le symbole monétaire.

CurrencyDecimalDigits

Définit le nombre par défaut de chiffres décimaux dans une valeur monétaire. Cette valeur peut être substituée à l'aide du spécificateur de précision.

CurrencyDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

CurrencyGroupSeparator

Définit la chaîne qui sépare les groupes de nombres de la partie entière.

CurrencyGroupSizes

Définit le nombre de chiffres entiers qui s'affichent dans un groupe.

L'exemple suivant met en forme une valeur Double avec le spécificateur de format monétaire.

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

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

Retour au tableau

Spécificateur de format décimal ("D")

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. Ce format est pris en charge par les types intégraux uniquement.

Le spécificateur de précision indique le nombre minimal de chiffres voulu dans la chaîne résultante. 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. 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.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. Comme le montre le tableau suivant, une seule propriété affecte la mise en forme de la chaîne de résultat.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

L'exemple suivant met en forme une valeur Int32 avec le spécificateur de format décimal.

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

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

Retour au tableau

Spécificateur de format exponentiel ("E")

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). La chaîne commence par un signe moins si le nombre est négatif. Un chiffre exactement précède toujours la virgule décimale.

Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale. 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.

La casse du spécificateur de format indique si le préfixe "E" ou "e" doit être ajouté à l'exposant. L'exposant est toujours constitué d'un signe plus ou moins et d'un minimum de trois chiffres. Le cas échéant, des zéros sont ajoutés à l'exposant pour respecter ce minimum.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif à la fois pour le coefficient et pour l'exposant.

NumberDecimalSeparator

Définit la chaîne qui sépare le chiffre intégral des chiffres décimaux dans le coefficient.

PositiveSign

Définit la chaîne qui indique qu'un exposant est positif.

L'exemple suivant met en forme une valeur Double avec le spécificateur de format exponentiel.

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

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

Retour au tableau

Spécificateur de format à virgule fixe ("F")

Le spécificateur de format à virgule fixe ("F") convertit un nombre en une chaîne au format "-ddd.ddd…" où chaque "d" correspond à un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif.

Le spécificateur de précision indique le nombre de décimales voulu. Si le spécificateur de précision est omis, la propriété NumberFormatInfo.NumberDecimalDigits actuelle fournit la précision numérique.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. 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.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

NumberDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

NumberDecimalDigits

Définit le nombre par défaut de chiffres décimaux. Cette valeur peut être substituée à l'aide du spécificateur de précision.

L'exemple suivant met en forme une valeur Double et une valeur Int32 avec le spécificateur de format à virgule fixe.

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                        

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

Retour au tableau

Spécificateur de format général ("G")

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. 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. 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.

Type numérique

Précision par défaut

Byte ou SByte

3 chiffres

Int16 ou UInt16

5 chiffres

Int32 ou UInt32

10 chiffres

Int64

19 chiffres

UInt64

20 chiffres

BigInteger

29 chiffres

Single

7 chiffres

Double

15 chiffres

Decimal

29 chiffres

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. 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. 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.

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.

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". L'exposant contient au minimum deux chiffres. 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.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. 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.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

NumberDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

NumberDecimalDigits

Définit le nombre par défaut de chiffres décimaux. Cette valeur peut être substituée à l'aide du spécificateur de précision.

PositiveSign

Définit la chaîne qui indique qu'un exposant est positif.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format général.

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    

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

Retour au tableau

Spécificateur de format numérique ("N")

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. Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale. Si le spécificateur de précision est omis, le nombre de décimales est défini par la propriété NumberFormatInfo.NumberDecimalDigits actuelle.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. 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.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

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.

NumberGroupSizes

Définit le nombre de chiffres intégraux qui s'affichent entre les séparateurs de groupes.

NumberGroupSeparator

Définit la chaîne qui sépare les groupes de nombres de la partie entière.

NumberDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

NumberDecimalDigits

Définit le nombre par défaut de chiffres décimaux. Cette valeur peut être substituée à l'aide d'un spécificateur de précision.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format de nombre.

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 

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

Retour au tableau

Spécificateur de format pourcentage ("P")

Le spécificateur de format pourcentage ("P") multiplie un nombre par 100 et le convertit en une chaîne qui représente un pourcentage. Le spécificateur de précision indique le nombre de décimales voulu. 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.

Le tableau suivant répertorie les propriétés de NumberFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété de NumberFormatInfo

Description

PercentPositivePattern

Définit la position du symbole de pourcentage pour les valeurs positives.

PercentNegativePattern

Définit la position du symbole de pourcentage et le symbole négatif pour les valeurs négatives.

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

PercentSymbol

Définit le symbole de pourcentage.

PercentDecimalDigits

Définit le nombre par défaut de chiffres décimaux dans une valeur de pourcentage. Cette valeur peut être substituée à l'aide du spécificateur de précision.

PercentDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

PercentGroupSeparator

Définit la chaîne qui sépare les groupes de nombres de la partie entière.

PercentGroupSizes

Définit le nombre de chiffres entiers qui s'affichent dans un groupe.

L'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format pourcentage.

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 %

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 %

Retour au tableau

Spécificateur de format aller-retour ("R")

Le spécificateur de format aller-retour ("R") garantit qu'une valeur numérique qui est convertie en chaîne sera de nouveau analysée dans la même valeur numérique. Ce format est pris en charge uniquement pour les types Single, Double et BigInteger.

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. Lorsqu'une valeur Single ou Double est mise en forme à l'aide de ce spécificateur, elle est tout d'abord testée à l'aide du format général, avec 15 chiffres de précision pour une valeur Double et 7 chiffres de précision pour une valeur Single. Si la valeur est correctement analysée pour la même valeur numérique, elle est mise en forme à l'aide du spécificateur de format général. Si la valeur n'est pas analysée correctement dans la même valeur numérique, elle est mise en forme à l'aide de 17 chiffres de précision pour une valeur Double et de 9 chiffres de précision pour une valeur Single.

Bien que vous puissiez inclure un spécificateur de précision, il est ignoré. Les allers-retours prévalent sur la précision lorsque vous utilisez ce spécificateur.

Les informations de mise en forme de l'objet NumberFormatInfo actif affectent la chaîne de résultat. 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.

Propriété de NumberFormatInfo

Description

NegativeSign

Définit la chaîne qui indique qu'un nombre est négatif.

NumberDecimalSeparator

Définit la chaîne qui sépare les chiffres de la partie entière des chiffres de la partie décimale.

PositiveSign

Définit la chaîne qui indique qu'un exposant est positif.

L'exemple suivant met en forme des valeurs Double avec le spécificateur de format aller-retour.

Dim value As Double

value = Math.Pi
Console.WriteLine(value.ToString("r"))
' Displays 3.1415926535897931
Console.WriteLine(value.ToString("r", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 3,1415926535897931
value = 1.623e-21
Console.WriteLine(value.ToString("r"))
' Displays 1.623E-21

double value;

value = Math.PI;
Console.WriteLine(value.ToString("r"));
// Displays 3.1415926535897931
Console.WriteLine(value.ToString("r", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 3,1415926535897931
value = 1.623e-21;
Console.WriteLine(value.ToString("r"));
// Displays 1.623E-21

Retour au tableau

Spécificateur de format hexadécimal ("X")

Le spécificateur de format hexadécimal ("X") convertit un nombre en une chaîne de chiffres hexadécimaux. 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. Par exemple, utilisez "X" pour produire "ABCDEF" et "x" pour produire "abcdef". Ce format est pris en charge par les types intégraux uniquement.

Le spécificateur de précision indique le nombre minimal de chiffres voulu dans la chaîne résultante. 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.

Les informations de mise en forme de l'objet NumberFormatInfo actif n'affectent pas la chaîne de résultat.

L'exemple suivant met en forme des valeurs Int32 avec le spécificateur de format hexadécimal.

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

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

Retour au tableau

Remarques

Paramètres du panneau de configuration

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. 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. Les ordinateurs qui utilisent des paramètres différents génèrent des chaînes de résultat différentes.

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. 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.

Propriétés NumberFormatInfo

La mise en forme dépend des propriétés de l'objet NumberFormatInfo actuel, qui est fourni implicitement par la culture du thread actuel ou explicitement par le paramètre IFormatProvider de la méthode qui appelle la mise en forme. Spécifiez un objet NumberFormatInfo ou CultureInfo pour ce paramètre.

Types numériques intégraux et à virgule flottante

Certaines descriptions de spécificateurs de format numériques standard font référence à des types numériques intégraux ou à virgule flottante. Les types numériques intégraux sont Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 et BigInteger. Les types numériques à virgule flottante sont Decimal, Single et Double.

Infinis à virgule flottante et 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.

Exemple

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. 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).

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

using System;
using System.Globalization;
using System.Threading;

public class NumericFormats
{
   public static void Main()
   {
      // 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();
   }
}

Voir aussi

Tâches

Comment : remplir un nombre avec des zéros non significatifs

Référence

NumberFormatInfo

Concepts

Chaînes de format numériques personnalisées

Mise en forme des types

Historique des modifications

Date

Historique

Motif

Mars 2011

Ajout d'un lien vers l'utilitaire de formatage.

Améliorations apportées aux informations.

Juillet 2010

Notez que l'arrondissement à une valeur différente de zéro est utilisé avec la chaîne de format standard "C".

Commentaires client.