Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Les chaînes de format numérique standard sont utilisées pour mettre en forme des types numériques courants. Une chaîne de format numérique standard prend la forme [format specifier][precision specifier]
, où :
Le spécificateur de format est un caractère alphabétique unique qui spécifie le type de format numérique, par exemple, devise ou pourcentage. Toute chaîne de format numérique qui contient plusieurs caractères alphabétiques, y compris des espaces blancs, est interprétée comme une chaîne de format numérique personnalisée. Pour plus d’informations, consultez chaînes de format numérique personnalisées.
Le spécificateur de précision est un entier facultatif qui affecte le nombre de chiffres dans la chaîne résultante. Dans .NET 7 et versions ultérieures, la valeur de précision maximale est de 999 999 999. Dans .NET 6, la valeur de précision maximale est Int32.MaxValue. Dans les versions précédentes de .NET, la précision peut aller de 0 à 99. Le spécificateur de précision contrôle le nombre de chiffres dans la représentation sous forme de chaîne d’un nombre. Il n’arrondit pas le nombre lui-même. Pour effectuer une opération d’arrondi, utilisez le , Math.Floorou Math.Round la Math.Ceilingméthode.
Lorsque le spécificateur de précision contrôle le nombre de chiffres fractionnaires dans la chaîne de résultat, la chaîne de résultat reflète un nombre arrondi à un résultat représentant le plus proche du résultat infiniment précis. S’il existe deux résultats tout aussi quasiment représentatifs :
- Sur .NET Framework et .NET Core jusqu’à .NET Core 2.0, le runtime sélectionne le résultat avec le chiffre le moins significatif (c’est-à-dire, en utilisant MidpointRounding.AwayFromZero).
- Sur .NET Core 2.1 et versions ultérieures, le runtime sélectionne le résultat avec un chiffre encore moins significatif (c’est-à-dire, en utilisant MidpointRounding.ToEven).
Remarque
Le spécificateur de précision détermine le nombre de chiffres dans la chaîne de résultat. 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 de largeur dans l’élément de format.
Les chaînes de format numérique standard sont prises en charge par :
Certaines surcharges de la
ToString
méthode de tous les types numériques. Par exemple, vous pouvez fournir une chaîne de format numérique aux méthodes et Int32.ToString(String, IFormatProvider) aux Int32.ToString(String) méthodes.Méthode
TryFormat
de tous les types numériques, par exemple, Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) et Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).Fonctionnalité de mise en forme composite .NET, utilisée par certaines
Write
etWriteLine
méthodes des Console classes StreamWriter , de la String.Format méthode et de la StringBuilder.AppendFormat méthode. La fonctionnalité de format composite vous permet d’inclure la représentation sous forme de chaîne de plusieurs éléments de données dans une seule chaîne, de spécifier la largeur du champ et d’aligner les nombres dans un champ. Pour plus d’informations, consultez Mise en forme composite.Chaînes interpolées en C# et Visual Basic, qui fournissent une syntaxe simplifiée par rapport aux chaînes de format composite.
Conseil / Astuce
Vous pouvez télécharger l’utilitaire de mise en forme, une application Windows Forms .NET Core qui vous permet d’appliquer des chaînes de format à des valeurs numériques ou de date et d’heure et affiche la chaîne de résultat. Le code source est disponible pour C# et Visual Basic.
Spécificateurs de format standard
Le tableau suivant décrit les spécificateurs de format numérique standard et affiche l’exemple de sortie produit par chaque spécificateur de format. Pour plus d’informations sur l’utilisation de chaînes de format numérique standard, consultez la sectionNotes pour obtenir une illustration complète de leur utilisation.
Le résultat d’une chaîne mise en forme pour une culture spécifique peut différer des exemples suivants. Les paramètres du système d’exploitation, les paramètres utilisateur, les variables d’environnement et la version .NET que vous utilisez peuvent tous affecter le format. Par exemple, à partir de .NET 5, .NET tente d’unifier les formats culturels entre les plateformes. Pour plus d’informations, consultez la globalisation et l’ICU .NET.
Spécificateur de format | Nom | Descriptif | Exemples |
---|---|---|---|
« B » ou « b » | Binaire | Résultat : chaîne binaire. Pris en charge par : Types intégraux uniquement (.NET 8+). Spécificateur de précision : nombre de chiffres dans la chaîne de résultat. Plus d’informations : Spécificateur de format binaire (« B »). |
42 (« B ») -> 101010 255 (« b16 ») -> 0000000011111111 |
« C » ou « c » | Monnaie | Résultat : 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 NumberFormatInfo.CurrencyDecimalDigits. Plus d’informations : 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.456 (« C3 », en-US) -> (\$123.456) -123.456 (« C3 », fr-FR) -> -123,456 € -123.456 (« C3 », ja-JP) -> ->123.456 |
« D » ou « d » | Décimal | Résultat : chiffres entiers avec signe négatif facultatif. Pris en charge par : 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. Plus d’informations : Spécificateur de format Decimal(« D »). |
1234 (« D ») -> 1234 -1234 (« D6 ») -> -001234 |
« E » ou « e » | Exponentielle (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. Plus d’informations : 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 » | Point fixe | Résultat : chiffres intégraux et décimaux avec 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 NumberFormatInfo.NumberDecimalDigits. Plus d’informations : Spécificateur de format Fixed-Point (« 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éralités | Résultat : plus compact de notation 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. Plus d’informations : Spécificateur de format général (« 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 » | Numéro | Résultat : chiffres intégraux et décimaux, séparateurs de groupe et séparateur décimal avec 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 NumberFormatInfo.NumberDecimalDigits. Plus d’informations : Spécificateur de format numérique (« N »). |
1234.567 (« N », en-US) -> 1 234,57 1234.567 (« N », ru-RU) -> 1 234 57 1234 (« N1 », en-US) -> 1 234.0 1234 (« N1 », ru-RU) -> 1 234 00 -1234.56 (« N3 », en-US) -> -1 234.560 -1234.56 (« N3 », 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 NumberFormatInfo.PercentDecimalDigits. Plus d’informations : 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 aller-retour à un nombre identique. Pris en charge par : Single, Double et BigInteger. Remarque : Recommandé pour le BigInteger type uniquement. Pour Double les types, utilisez « G17 » ; pour Single les types, utilisez « G9 ». Spécificateur de précision : ignoré. Plus d’informations : 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 : Types intégraux uniquement. Spécificateur de précision : nombre de chiffres dans la chaîne de résultat. Plus d’informations : Spécificateur de format hexadécimal (« X »). |
255 (« X ») -> FF -1 (« x ») -> ff 255 (« x4 ») -> 00ff -1 (« X4 ») -> 00FF |
Tout autre caractère unique | Spécificateur inconnu | Résultat : lève une FormatException valeur au moment de l’exécution. |
Utiliser des chaînes de format numérique standard
Remarque
Les exemples C# de cet article s’exécutent dans le Try.NET exécuteur de code inline et le terrain de jeu. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive. Une fois que vous avez exécuté le code, vous pouvez le modifier et l’exécuter en sélectionnant Exécuter à nouveau. 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#.
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 manières suivantes :
Il peut être passé à la
TryFormat
méthode ou à une surcharge de laToString
méthode qui a unformat
paramètre. L’exemple suivant met en forme une valeur numérique en tant que chaîne monétaire dans la culture actuelle (dans ce cas, la culture en-US).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
Il peut être fourni en tant qu’argument
formatString
dans un élément de format utilisé avec des méthodes telles que String.Format, Console.WriteLineet StringBuilder.AppendFormat. Pour plus d’informations, consultez Mise en forme composite. L’exemple suivant utilise un élément de format pour insérer une valeur monétaire dans une chaîne.decimal value = 123.456m; Console.WriteLine($"Your account balance is {value:C2}."); // 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."
Si vous le souhaitez, vous pouvez fournir un
alignment
argument pour spécifier la largeur du champ numérique et indiquer si sa valeur est alignée à droite ou à gauche. L’exemple suivant aligne à gauche une valeur monétaire dans un champ de 28 caractères, et il aligne à droite une valeur monétaire dans un champ de 14 caractères.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é d’une chaîne interpolée. Pour plus d’informations, consultez l’article d’interpolation de chaîne dans la référence C# ou l’article sur les chaînes interpolées dans la référence Visual Basic.
Les sections suivantes fournissent des informations détaillées sur chacune des chaînes de format numérique standard.
Spécificateur de format binaire (B)
Le spécificateur de format binaire (« B ») convertit un nombre en chaîne de chiffres binaires. Ce format est pris en charge uniquement pour les types intégraux et uniquement sur .NET 8+.
Le spécificateur de précision indique le nombre minimal de chiffres souhaités dans la chaîne résultante. Si nécessaire, le nombre est rembourré avec des zéros à sa gauche pour produire le nombre de chiffres donnés par le spécificateur de précision.
La chaîne de résultat n’est pas affectée par les informations de mise en forme de l’objet actif NumberFormatInfo .
Spécificateur de format monétaire (C)
Le spécificateur de format « C » (ou devise) convertit un nombre en chaîne qui représente un montant monétaire. 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 NumberFormatInfo.CurrencyDecimalDigits propriété.
Si la valeur à mettre en forme a plus que le nombre spécifié ou par défaut de décimales, la valeur fractionnaire est arrondie dans la chaîne de résultat. Si la valeur à droite du nombre de décimales spécifiées est de 5 ou supérieure, le dernier chiffre de la chaîne de résultat est arrondi à zéro.
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne retournée.
NumberFormatInfo, propriété | Descriptif |
---|---|
CurrencyPositivePattern | Définit le placement du symbole monétaire pour les valeurs positives. |
CurrencyNegativePattern | Définit le placement 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 la NegativeSign propriété. |
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 remplacée à l’aide du spécificateur de précision. |
CurrencyDecimalSeparator | Définit la chaîne qui sépare les chiffres intégral et décimal. |
CurrencyGroupSeparator | Définit la chaîne qui sépare les groupes de nombres intégraux. |
CurrencyGroupSizes | Définit le nombre de chiffres entiers qui apparaissent dans un groupe. |
L’exemple suivant met en forme une Double valeur avec le spécificateur de format monétaire :
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
Spécificateur de format décimal (D)
Le spécificateur de format « D » (ou décimal) convertit un nombre en chaîne de chiffres décimaux (0-9), précédé d’un signe moins si le nombre est négatif. Ce format est pris en charge uniquement pour les types intégraux.
Le spécificateur de précision indique le nombre minimal de chiffres souhaités dans la chaîne résultante. Si nécessaire, le nombre est rembourré avec des zéros à sa gauche pour produire le nombre de chiffres donnés 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.
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Comme le montre le tableau suivant, une propriété unique affecte la mise en forme de la chaîne de résultat.
NumberFormatInfo, propriété | Descriptif |
---|---|
NegativeSign | Définit la chaîne qui indique qu’un nombre est négatif. |
L’exemple suivant met en forme une Int32 valeur 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
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
Spécificateur de format exponentiel (E)
Le spécificateur de format exponentiel (« E ») convertit un nombre en chaîne du formulaire « -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. Exactement un chiffre précède toujours le point décimal.
Le spécificateur de précision indique le nombre de chiffres souhaité après la virgule décimale. Si le spécificateur de précision est omis, la valeur par défaut est de six chiffres après l’utilisation du point décimal.
Le cas du spécificateur de format indique s’il faut préfixer l’exposant avec un « E » ou un « e ». L’exposant se compose toujours d’un signe plus ou moins et d’un minimum de trois chiffres. L’exposant est rembourré avec des zéros pour répondre à ce minimum, si nécessaire.
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne retournée.
NumberFormatInfo, propriété | Descriptif |
---|---|
NegativeSign | Définit la chaîne qui indique qu’un nombre est négatif pour le coefficient et 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 Double valeur avec le spécificateur de format exponentiel :
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
Spécificateur de format de point fixe (F)
Le spécificateur de format de point fixe (« F ») convertit un nombre en chaîne du formulaire « -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 souhaité de décimales. Si le spécificateur de précision est omis, la propriété actuelle NumberFormatInfo.NumberDecimalDigits fournit la précision numérique.
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les propriétés de l’objet NumberFormatInfo qui contrôlent la mise en forme de la chaîne de résultat.
NumberFormatInfo, propriété | Descriptif |
---|---|
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 intégraux des chiffres décimaux. |
NumberDecimalDigits | Définit le nombre par défaut de chiffres décimaux. Cette valeur peut être remplacée à l’aide du spécificateur de précision. |
L’exemple suivant met en forme une Double valeur et une Int32 valeur avec le spécificateur de format de point 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
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
Spécificateur de format général (G)
Le spécificateur de format général (« G ») convertit un nombre en nombre plus compact de notation fixe ou scientifique, selon le type du nombre et si un spécificateur de précision est présent. Le spécificateur de précision définit le nombre maximal de chiffres significatifs qui peuvent apparaître dans la chaîne de résultat. Si le spécificateur de précision est omis ou 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 | Illimité (identique à « R » ) |
Half | Plus petit nombre de chiffres aller-retour pour représenter le nombre |
Single | Petit nombre de chiffres aller-retour le plus petit pour représenter le nombre (dans .NET Framework, G7 est la valeur par défaut) |
Double | Plus petit nombre de chiffres aller-retour pour représenter le nombre (dans .NET Framework, G15 est la valeur par défaut) |
Decimal | Plus petit nombre de chiffres aller-retour pour représenter le nombre |
La notation à point 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 ; sinon, la notation scientifique est utilisée. Le résultat contient un point décimal si nécessaire et les zéros de fin après l’omission du point décimal. Si le spécificateur de précision est présent et que le nombre de chiffres significatifs dans le résultat dépasse la précision spécifiée, les chiffres de fin excédentaires sont supprimés en arrondissant.
Toutefois, si le nombre est un Decimal spécificateur de précision et que le spécificateur de précision est omis, la notation à point fixe est toujours utilisée et les zéros de fin sont conservés.
Si la notation scientifique est utilisée, l’exposant dans le résultat est précédé de « E » si le spécificateur de format est « G » ou « e » si le spécificateur de format est « g ». L’exposant contient un minimum de deux chiffres. Cela diffère du format de notation scientifique généré par le spécificateur de format exponentiel, qui inclut un minimum de trois chiffres dans l’exposant.
Lorsqu’il est utilisé avec une Double valeur, le spécificateur de format « G17 » garantit que la valeur d’origine Double réussit à aller-retour. Cela est dû au fait qu’il Double s’agit d’un nombre àbinary64
virgule flottante conforme à l’IEEE 754-2008 qui donne jusqu’à 17 chiffres significatifs de précision. Sur .NET Framework, nous vous recommandons d’utiliser son utilisation au lieu du spécificateur de format « R », car dans certains cas, « R » ne parvient pas à effectuer un aller-retour avec succès des valeurs à virgule flottante double précision.
Lorsqu’il est utilisé avec une Single valeur, le spécificateur de format « G9 » garantit que la valeur d’origine Single est correctement aller-retour. Cela est dû au fait qu’il Single s’agit d’un nombre à virgule flottante conforme àbinary32
l’IEEE 754-2008 qui donne jusqu’à neuf chiffres significatifs de précision. Pour des raisons de performances, nous vous recommandons d’utiliser son utilisation au lieu du spécificateur de format « R ».
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne de résultat.
NumberFormatInfo, propriété | Descriptif |
---|---|
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 intégraux des chiffres décimaux. |
PositiveSign | Définit la chaîne qui indique qu’un exposant est positif. |
L’exemple suivant met en forme des valeurs à virgule flottante 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
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
Spécificateur de format numérique (N)
Le spécificateur de format numérique (« N ») convertit un nombre en chaîne du formulaire « -d,ddd,ddd.ddd... », où « - » indique un symbole de nombre négatif si nécessaire, « d » indique un chiffre (0-9), « », indique un séparateur de groupe et « ». indique un symbole décimal. Le spécificateur de précision indique le nombre de chiffres souhaité 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é actuelle NumberFormatInfo.NumberDecimalDigits .
La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne de résultat.
NumberFormatInfo, propriété | Descriptif |
---|---|
NegativeSign | Définit la chaîne qui indique qu’un nombre est négatif. |
NumberNegativePattern | Définit le format des valeurs négatives et spécifie si le signe négatif est représenté par des parenthèses ou la NegativeSign propriété. |
NumberGroupSizes | Définit le nombre de chiffres intégraux qui apparaissent entre les séparateurs de groupes. |
NumberGroupSeparator | Définit la chaîne qui sépare les groupes de nombres intégraux. |
NumberDecimalSeparator | Définit la chaîne qui sépare les chiffres intégral et décimal. |
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 avec le spécificateur de format numérique :
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
Spécificateur de format de pourcentage (P)
Le spécificateur de format pourcentage (« P ») multiplie un nombre par 100 et le convertit en chaîne qui représente un pourcentage. Le spécificateur de précision indique le nombre souhaité de décimales. Si le spécificateur de précision est omis, la précision numérique par défaut fournie par la propriété actuelle PercentDecimalDigits est utilisée.
Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne retournée.
NumberFormatInfo, propriété | Descriptif |
---|---|
PercentPositivePattern | Définit le placement du symbole de pourcentage pour les valeurs positives. |
PercentNegativePattern | Définit le placement 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 remplacée à l’aide du spécificateur de précision. |
PercentDecimalSeparator | Définit la chaîne qui sépare les chiffres intégral et décimal. |
PercentGroupSeparator | Définit la chaîne qui sépare les groupes de nombres intégraux. |
PercentGroupSizes | Définit le nombre de chiffres entiers qui apparaissent dans un groupe. |
L’exemple suivant met en forme les valeurs à virgule flottante avec le spécificateur de format de 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 %
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 %
Spécificateur de format aller-retour (R)
Le spécificateur de format aller-retour (« R ») tente de s’assurer qu’une valeur numérique convertie en chaîne est analysée dans la même valeur numérique. Ce format est pris en charge uniquement pour les types, et SingleDoubleBigInteger les Halftypes.
Dans .NET Framework et dans les versions .NET Core antérieures à la version 3.0, le spécificateur de format « R » ne parvient pas à effectuer des allers-retours Double dans certains cas. Pour les deux Double et Single les valeurs, le spécificateur de format « R » offre des performances relativement médiocres. Au lieu de cela, nous vous recommandons d’utiliser le spécificateur de format « G17 » pour Double les valeurs et le spécificateur de format « G9 » pour effectuer un aller-retour Single réussi.
Lorsqu’une BigInteger valeur 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 BigInteger valeur.
Bien que vous puissiez inclure un spécificateur de précision, il est ignoré. Les allers-retours sont prioritaires sur la précision lors de l’utilisation de ce spécificateur. La chaîne de résultat est affectée par les informations de mise en forme de l’objet actif NumberFormatInfo . Le tableau suivant répertorie les NumberFormatInfo propriétés qui contrôlent la mise en forme de la chaîne de résultat.
NumberFormatInfo, propriété | Descriptif |
---|---|
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 intégraux des chiffres décimaux. |
PositiveSign | Définit la chaîne qui indique qu’un exposant est positif. |
L’exemple suivant met en forme une BigInteger valeur avec le spécificateur de format aller-retour.
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, Double les valeurs mises en forme avec la chaîne de format numérique standard « R » ne sont pas correctement aller-retour si elles sont compilées à l’aide des /platform:x64
commutateurs ou /platform:anycpu
s’exécutent sur des systèmes 64 bits. Pour plus d’informations, consultez le paragraphe suivant.
Pour contourner le problème des Double valeurs mises en forme avec la chaîne de format numérique standard « R » qui n’est pas correctement aller-retour si elle est compilée à l’aide des /platform:x64
commutateurs ou /platform:anycpu
des commutateurs et exécutées sur des systèmes 64 bits, vous pouvez mettre en forme Double des valeurs à l’aide de la chaîne de format numérique standard « G17 ». L’exemple suivant utilise la chaîne de format « R » avec une Double valeur qui n’effectue pas un aller-retour réussi, et utilise également la chaîne de format « G17 » pour effectuer un aller-retour réussi la valeur d’origine :
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($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");
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($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// 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':
// .NET Framework:
// 0.6822871999174 = 0.68228719991740006: False
// .NET:
// 0.6822871999174 = 0.6822871999174: True
//
// 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':
' .NET Framework:
' 0.6822871999174 = 0.68228719991740006: False
' .NET:
' 0.6822871999174 = 0.6822871999174: True
'
' Attempting to round-trip a Double with 'G17':
' 0.6822871999174 = 0.6822871999174: True
Spécificateur de format hexadécimal (X)
Le spécificateur de format hexadécimal (« X ») convertit un nombre en chaîne de chiffres hexadécimaux. Le cas du spécificateur de format indique s’il faut 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 uniquement pour les types intégraux.
Le spécificateur de précision indique le nombre minimal de chiffres souhaités dans la chaîne résultante. Si nécessaire, le nombre est rembourré avec des zéros à sa gauche pour produire le nombre de chiffres donnés par le spécificateur de précision.
La chaîne de résultat n’est pas affectée par les informations de mise en forme de l’objet actif NumberFormatInfo .
L’exemple suivant met en forme Int32 les valeurs 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
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
Remarques
Cette section contient des informations supplémentaires sur l’utilisation de chaînes de format numérique standard.
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 de résultat produite par une opération de mise en forme. Ces paramètres sont utilisés pour initialiser l’objet associé à la culture actuelle, qui fournit des valeurs utilisées pour régir la NumberFormatInfo mise en forme. Les ordinateurs qui utilisent différents paramètres génèrent des chaînes de résultats différentes.
En outre, si le CultureInfo(String) constructeur est utilisé pour instancier un nouvel CultureInfo objet qui représente la même culture que la culture système actuelle, toutes les personnalisations établies par l’élément Options régionales et linguistiques dans le Panneau de configuration sont appliquées au nouvel CultureInfo objet. Vous pouvez utiliser le CultureInfo(String, Boolean) constructeur pour créer un CultureInfo objet qui ne reflète pas les personnalisations d’un système.
Propriétés NumberFormatInfo
La mise en forme est influencée par les propriétés de l’objet actuel NumberFormatInfo , qui est fournie implicitement par la culture actuelle ou explicitement par le IFormatProvider paramètre de la méthode qui appelle la mise en forme. Spécifiez un ou CultureInfo un NumberFormatInfo objet pour ce paramètre.
Remarque
Pour plus d’informations sur la personnalisation des modèles ou des chaînes utilisés dans la mise en forme de valeurs numériques, consultez la NumberFormatInfo rubrique de classe.
Types numériques intégraux et à virgule flottante
Certaines descriptions des spécificateurs de format numérique standard font référence à des types numériques intégraux ou à virgule flottante. Les types numériques intégraux sont Byte, , SByteInt16, Int64UInt32UInt16Int32, UInt64, et .BigInteger Les types numériques à virgule flottante sont Decimal, Half, Singleet Double.
Infinis à virgule flottante et NaN
Quelle que soit la chaîne de format, si la valeur d’un Halftype à Singlevirgule flottante ou Double un type à virgule flottante est l’infini positif, l’infini négatif ou non un nombre (NaN), la chaîne mise en forme est la valeur de la propriété respective PositiveInfinitySymbol, NegativeInfinitySymbolou NaNSymbol spécifiée par l’objet actuellement applicable NumberFormatInfo .
Exemple de code
L’exemple suivant met en forme une valeur numérique intégrale et à virgule flottante à l’aide de la culture en-US et de tous les spécificateurs de format numérique standard. Cet exemple utilise deux types numériques particuliers (Double et Int32), mais génère des résultats similaires pour l’un des autres types de base numériques (Byte, , SByte, UInt16UInt32Int32Int64UInt64Int16, , , BigIntegerDecimalHalfet ).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: {floating.ToString("C", ci)}"); // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}"); // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}"); // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}"); // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}"); // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}"); // Displays "R: 10761.937554"
Console.WriteLine();
// Output integral values
int integral = 8395;
Console.WriteLine($"C: {integral.ToString("C", ci)}"); // Displays "C: $8,395.00"
Console.WriteLine($"D: {integral.ToString("D6", ci)}"); // Displays "D: 008395"
Console.WriteLine($"E: {integral.ToString("E03", ci)}"); // Displays "E: 8.395E+003"
Console.WriteLine($"F: {integral.ToString("F01", ci)}"); // Displays "F: 8395.0"
Console.WriteLine($"G: {integral.ToString("G", ci)}"); // Displays "G: 8395"
Console.WriteLine($"N: {integral.ToString("N01", ci)}"); // Displays "N: 8,395.0"
Console.WriteLine($"P: {(integral/10000.0).ToString("P02", ci)}"); // Displays "P: 83.95 %"
Console.WriteLine($"X: 0x{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