Chaînes de format numériques standard

Mise à jour : novembre 2007

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.

Le tableau suivant décrit les spécificateurs de format numériques standard et affiche une sortie produite par chaque spécificateur de format. Pour plus d'informations, consultez les notes qui suivent le tableau.

Spécificateur de format

Nom

Description

C ou c

Devise

Le nombre est converti en une chaîne représentant une valeur monétaire. La conversion est contrôlée par les informations sur le format monétaire de l'objet NumberFormatInfo en cours.

Le spécificateur de précision indique le nombre de décimales voulu. Si vous avez omis le spécificateur de précision, la précision monétaire par défaut fournie par l'objet NumberFormatInfo en cours est utilisée.

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

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.InvariantCulture));
// Displays 12,345.68 

Console.WriteLine(value.ToString("C3", CultureInfo.InvariantCulture));
// Displays 12,345.679

Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays $12,345.679


D ou d

Décimal

Ce format est pris en charge par les types intégraux uniquement. Le nombre est converti en une chaîne de chiffres décimaux (0-9), précédée d'un signe moins si le nombre est négatif.

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.

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

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


E ou e

Scientifique (exponentiel)

Le nombre est converti en une chaîne au format « -d.ddd...E+ddd » ou « -d.ddd...e+ddd », où chaque « d » indique un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif. Un chiffre 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.

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

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


F ou f

Virgule fixe

Le nombre est converti en une chaîne au format « -ddd.ddd... », où chaque « d » indique 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 vous avez omis le spécificateur de précision, la précision numérique par défaut est fournie par la propriété NumberDecimalDigits de l'objet NumberFormatInfo en cours.

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

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                        


G ou g

Général

Le nombre est converti dans le format le plus compact (virgule fixe ou notation scientifique), selon le type du nombre et en fonction de la présence d'un spécificateur de précision. 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é par la liste suivante.

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 une virgule décimale si nécessaire et les zéros de fin sont omis. Si le spécificateur de précision est présent et le nombre de chiffres significatifs dans le résultat excède la précision indiquée, les chiffres de fin en trop sont supprimés en arrondissant.

La règle précédente présente une exception si le nombre est de type Decimal et le spécificateur de précision est omis. Dans ce cas, 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'exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format général.

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    


N ou n

Nombre

Le nombre est converti 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 milliers entre les groupes de nombres et « . » correspond à une virgule décimale. Le modèle de nombre négatif, la taille du groupe de nombres, le séparateur de milliers et le séparateur décimal réels sont spécifiés par les propriétés respectives NumberNegativePattern, NumberGroupSizes, NumberGroupSeparator et NumberDecimalSeparator de l'objet NumberFormatInfo en cours.

Le spécificateur de précision indique le nombre de décimales voulu. Si vous avez omis le spécificateur de précision, la précision numérique par défaut est fournie par la propriété NumberDecimalDigits de l'objet NumberFormatInfo en cours.

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

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 -12445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0 


P ou p

Pourcentage

Le nombre est converti en une chaîne qui représente un pourcentage, comme défini par la propriété NumberFormatInfo.PercentNegativePattern si le nombre est négatif, ou NumberFormatInfo.PercentPositivePattern si le nombre est positif. Le nombre converti est multiplié par 100 afin d'être présenté comme un pourcentage.

Le spécificateur de précision indique le nombre de décimales voulu. Si vous avez omis le spécificateur de précision, la précision numérique par défaut fournie par l'objet NumberFormatInfo en cours est utilisée.

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

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 %


R ou r

Aller-retour

Ce format est pris en charge par les types Single et Double uniquement. Le spécificateur d'aller-retour garantit qu'une valeur numérique convertie en chaîne sera analysée dans la même valeur numérique. Lorsqu'une valeur numérique est mise en forme avec ce spécificateur, elle est tout d'abord testée à l'aide du format général, avec 15 espaces de précision pour une valeur Double et 7 espaces 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. Cependant, si la valeur n'est pas analysée correctement dans la même valeur numérique, la valeur 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 qu'un spécificateur de précision soit présent, il est ignoré. Les allers-retours prévalent sur la précision lorsque vous utilisez ce spécificateur.

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

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


X ou x

Hexadécimal

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

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.

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

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


N'importe quel caractère

(Spécificateur inconnu)

(Un spécificateur inconnu lève une FormatException au moment de l'exécution.)

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 en cours et la culture du thread en cours fournit des valeurs utilisées pour indiquer la mise en forme. Les ordinateurs utilisant des paramètres différents génèrent des chaînes résultantes 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 la méthode CultureInfo.CreateSpecificCulture pour créer un 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 en cours, qui est fourni implicitement par la culture du thread en cours 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 et UInt64. Les types numériques à virgule flottante sont Decimal, Single et Double.

Infinis à virgule flottante et NaN

Notez que 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 spécifiée par l'objet NumberFormatInfo actuellement applicable.

L'exemple suivant met en forme une valeur intégrale et une valeur numérique à 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, mais produirait des résultats similaires pour n'importe lequel des types numériques de base (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Decimal, Single et Double).

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).ToString("P02", ci)); // Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", 
              integral.ToString("X", ci));           // Displays "X: 0x20CB"
      Console.WriteLine();
   }
}


Ajouts de la communauté

Afficher: