Exporter (0) Imprimer
Développer tout

Chaînes de format numériques standard

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. Pour obtenir des exemples de la sortie produite par chaque spécificateur de format, consultez Exemples de sortie de chaînes de format numériques standard. 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.

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.

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.

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 fournie par l'objet NumberFormatInfo en cours.

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.

  • Byte ou SByte : 3

  • Int16 ou UInt16 : 5

  • Int32 ou UInt32 : 10

  • Int64 ou UInt64 : 19

  • Single : 7

  • Double : 15

  • Decimal : 29

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

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 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 fournie par l'objet NumberFormatInfo en cours.

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.

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 aller-retour prévalent sur la précision lorsque vous utilisez ce spécificateur.

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.

N'importe quel caractère

(Spécificateur inconnu)

(Un spécificateur inconnu lève une exception de format du runtime.)

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

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.

Exemple

L'exemple de code suivant met en forme une valeur intégrale et une valeur numérique à virgule flottante en utilisant la culture en cours du thread, une culture spécifiée et tous les spécificateurs de format numériques standard. Cet exemple de code utilise deux types numériques particuliers, mais produirait des résultats semblables pour n'importe quel type de base numérique (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Decimal, Single et Double).

// This code example demonstrates the ToString(String) and 
// ToString(String, IFormatProvider) methods for integral and
// floating-point numbers, in conjunction with the standard 
// numeric format specifiers.
// This code example uses the System.Int32 integral type and 
// the System.Double floating-point type, but would yield 
// similar results for any of the numeric types. The integral 
// numeric types are System.Byte, SByte, Int16, Int32, Int64, 
// UInt16, UInt32, and UInt64. The floating-point numeric types 
// are Decimal, Single, and Double.

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

class Sample 
{
    public static void Main() 
    {
// Format a negative integer or floating-point number in various ways.
    int    integralVal = -12345;
    double floatingVal = -1234.567d;

    string msgCurrency =    "(C) Currency: . . . . . . ";
    string msgDecimal  =    "(D) Decimal:. . . . . . . ";
    string msgScientific =  "(E) Scientific: . . . . . ";
    string msgFixedPoint =  "(F) Fixed point:. . . . . ";
    string msgGeneral =     "(G) General (default):. . ";
    string msgNumber =      "(N) Number: . . . . . . . ";
    string msgPercent =     "(P) Percent:. . . . . . . ";
    string msgRoundTrip =   "(R) Round-trip: . . . . . ";
    string msgHexadecimal = "(X) Hexadecimal:. . . . . ";

    string msg1 = "Use ToString(String) and the current thread culture.\n";
    string msg2 = "Use ToString(String, IFormatProvider) and a specified culture.\n";
    string msgCulture     = "Culture:";
    string msgIntegralVal = "Integral value:";
    string msgFloatingVal = "Floating-point value:";

    CultureInfo ci;
//
    Console.Clear();
    Console.WriteLine("Standard Numeric Format Specifiers:\n");
// Display the values.
    Console.WriteLine(msg1);

// Display the thread current culture, which is used to format the values.
    ci = Thread.CurrentThread.CurrentCulture;
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D"));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X"));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double 
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R"));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C"));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E"));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F"));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G"));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N"));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P"));
    Console.WriteLine();

// Display the same values using a CultureInfo object. The CultureInfo class 
// implements IFormatProvider.
    Console.WriteLine(msg2);

// Display the culture used to format the values. 
// Create a European culture and change its currency symbol to "euro" because 
// this particular code example uses a thread current UI culture that cannot 
// display the euro symbol (€).
    ci = new CultureInfo("de-DE");
    ci.NumberFormat.CurrencySymbol = "euro";
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D", ci));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X", ci));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double 
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R", ci));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C", ci));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E", ci));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F", ci));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G", ci));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N", ci));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P", ci));
    Console.WriteLine();
    }
}
/*
This code example produces the following results:

Standard Numeric Format Specifiers:

Use ToString(String) and the current thread culture.

Culture:                  English (United States)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234.567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . ($1,234.57)
(E) Scientific: . . . . . -1.234567E+003
(F) Fixed point:. . . . . -1234.57
(G) General (default):. . -1234.567
(N) Number: . . . . . . . -1,234.57
(P) Percent:. . . . . . . -123,456.70 %

Use ToString(String, IFormatProvider) and a specified culture.

Culture:                  German (Germany)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234,567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . -1.234,57 euro
(E) Scientific: . . . . . -1,234567E+003
(F) Fixed point:. . . . . -1234,57
(G) General (default):. . -1234,567
(N) Number: . . . . . . . -1.234,57
(P) Percent:. . . . . . . -123.456,70%

*/

Voir aussi

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft