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 [format specifier][precision specifier], où :
Le spécificateur de format est un caractère alphabétique unique qui spécifie le type de format de nombre, par exemple devise ou pourcentage. 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.
Le spécificateur de précision est un entier facultatif qui affecte le nombre de chiffres dans la chaîne obtenue. Dans .NET 7 et versions ultérieures, la valeur de précision maximale est 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 être comprise entre 0 et 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 exécuter une opération d'arrondi, utilisez la méthode Math.Ceiling, Math.Floor ou Math.Round.
Quand le spécificateur de précision contrôle le nombre de chiffres fractionnaires dans la chaîne de résultat, celle-ci reflète un nombre qui est arrondi à un résultat représentable le plus proche du résultat précis à l’infini. S’il existe deux résultats représentables aussi proches l’un que l’autre :
- Sur .NET Framework et .NET Core jusqu’à .NET Core 2.0, le runtime sélectionne le résultat ayant le nombre le moins significatif le plus élevé (autrement dit à l’aide de MidpointRounding.AwayFromZero).
- Sur .NET Core 2.1 et versions ultérieures, le runtime sélectionne le résultat ayant un chiffre encore moins significatif (autrement dit, à l’aide de MidpointRounding.ToEven).
Notes
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 d’alignement dans l’élément de mise en forme.
Les chaînes de format numériques standard sont prises en charge par :
Certaines surcharges de la méthode
ToStringde tous les types numériques. Par exemple, vous pouvez fournir une chaîne de format numérique aux méthodes Int32.ToString(String) et Int32.ToString(String, IFormatProvider).Méthode
TryFormatde tous les types numériques, par exemple Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) et Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).La fonctionnalité de mise en forme composite .NET, utilisée par certaines méthodes
WriteetWriteLinedes classes Console et StreamWriter, la méthode String.Format et la méthode StringBuilder.AppendFormat. La fonctionnalité de mise en forme composite vous permet d’inclure la représentation sous forme de chaîne de plusieurs éléments de données dans une même chaîne, de spécifier la largeur d’un champ et d’aligner les nombres dans un champ. Pour plus d’informations, consultez Mise en forme composite.Les chaînes interpolées en C# et Visual Basic, qui fournissent une syntaxe simplifiée par rapport aux de chaînes de format composite.
Conseil
Vous pouvez télécharger l’utilitaire de mise en forme, application .NET Core Windows Forms qui vous permet d’appliquer des chaînes de mise en forme à des valeurs numériques ou à des valeurs de date et d’heure, et d’afficher la chaîne de résultat. 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é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 de code pour obtenir une illustration complète de leur utilisation.
Le résultat d’une chaîne mise en forme d’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 de .NET que vous utilisez peuvent tous affecter le format. À compter de .NET 5, .NET tente par exemple d’unifier les formats culturels dans les différentes plateformes. Pour plus d’informations, consultez Globalisation et ICU .NET.
| Spécificateur de format | Nom | Description | 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. Informations supplémentaires : Spécificateur de format binaire ("B"). |
42 ("B") -> 101010 255 ("b16") -> 0000000011111111 |
| "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 NumberFormatInfo.CurrencyDecimalDigits. 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 NumberFormatInfo.NumberDecimalDigits. 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" | Number | 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 NumberFormatInfo.NumberDecimalDigits. Informations supplémentaires : 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,0 -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. 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. Remarque : recommandé pour le type BigInteger uniquement. Pour les types Double, utilisez "G17" ; pour les types Single, utilisez "G9". 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" | Valeur hexadécimale | 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. |
Utiliser des chaînes de format numériques standard
Notes
Les exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET. 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 exécuter le code modifié en resélectionnant Exécuter. 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 :
Elle peut être transmise à la méthode
TryFormatou une surcharge de la méthodeToStringcomprenant un paramètreformat. 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).Decimal value = static_cast<Decimal>(123.456); Console::WriteLine(value.ToString("C2")); // Displays $123.46decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); // Displays $123.46Dim value As Decimal = 123.456d Console.WriteLine(value.ToString("C2")) ' Displays $123.46Elle peut être fournie comme argument
formatStringdans 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.Decimal value = static_cast<Decimal>(123.456); Console::WriteLine("Your account balance is {0:C2}.", value); // Displays "Your account balance is $123.46."decimal value = 123.456m; Console.WriteLine("Your account balance is {0:C2}.", value); // Displays "Your account balance is $123.46."Dim value As Decimal = 123.456d Console.WriteLine("Your account balance is {0:C2}.", value) ' Displays "Your account balance is $123.46."Vous pouvez éventuellement fournir un argument
alignmentpour spécifier la largeur du champ numérique et 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 aligne à droite une valeur monétaire dans un champ de 14 caractères.array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), static_cast<Decimal>(18794.16) }; Console::WriteLine(" Beginning Balance Ending Balance"); Console::WriteLine(" {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]); // Displays: // Beginning Balance Ending Balance // $16,305.32 $18,794.16decimal[] 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.16Dim 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.16Il peut être fourni en tant qu’argument
formatStringdans un élément d’expression interpolée d’une chaîne interpolée. Pour plus d’informations, consultez l’article Interpolation de chaîne dans les informations de référence sur C# ou l’article Chaînes interpolées dans les informations de référence sur Visual Basic.
Les sections suivantes fournissent des informations détaillées sur chacune des chaînes de format numériques 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 par les types intégraux et uniquement sur .NET 8+.
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.
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 :
double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));
Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));
Console::WriteLine(value.ToString("C3",
CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
// $12,345.68
// $12,345.679
// kr 12.345,679
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3",
CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
// $12,345.68
// $12,345.679
// 12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))
Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))
Console.WriteLine(value.ToString("C3", _
CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
' $12,345.68
' $12,345.679
' kr 12.345,679
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.
int value;
value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345
value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345
int value;
value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345
value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer
value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345
Console.WriteLine(value.ToString("D8"))
' Displays 00012345
value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345
Spécificateur de format exponentiel (D)
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 :
double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004
Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004
Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004
Console::WriteLine(value.ToString("E",
CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004
Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004
Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004
Console.WriteLine(value.ToString("E",
CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004
Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004
Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004
Console.WriteLine(value.ToString("E", _
CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004
Spécificateur de format à virgule fixe (F)
Le spécificateur de format à virgule fixe ("F") convertit un nombre en chaîne au format "-ddd.ddd…" où chaque "d" correspond à un chiffre (0-9). 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 :
int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F",
CultureInfo::InvariantCulture));
// Displays 17843.00
integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3",
CultureInfo::InvariantCulture));
// Displays -29541.000
double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19
Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934
doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));
// Displays -1898300.2
Console::WriteLine(doubleNumber.ToString("F3",
CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
CultureInfo.InvariantCulture));
// Displays 17843.00
integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
CultureInfo.InvariantCulture));
// Displays -29541.000
double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934
doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2
Console.WriteLine(doubleNumber.ToString("F3",
CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00
integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000
Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934
doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2
Console.WriteLine(doubleNumber.ToString("F3", _
CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199
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 | Illimité (identique à "R") |
| Half | Plus petit nombre de chiffres avec aller-retour pour représenter le nombre |
| Single | Plus petit nombre de chiffres avec aller-retour pour représenter le nombre (dans .NET Framework, G7 est la valeur par défaut) |
| Double | Plus petit nombre de chiffres avec aller-retour pour représenter le nombre (dans .NET Framework, G15 est la valeur par défaut) |
| Decimal | Plus petit nombre de chiffres avec aller-retour pour représenter le nombre |
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.
Quand il est utilisé avec une valeur Double, le spécificateur de format « G17 » garantit les allers-retours de la valeur Double originale. En effet, Double est un nombre à virgule flottante double précision (binary64) et conforme à la norme IEEE 754-2008, qui offre jusqu’à 17 chiffres de précision. Sur .NET Framework, nous recommandons de l’utiliser à la place du spécificateur de format « R » car, dans certains cas, « R » ne parvient pas à effectuer un aller-retour avec des valeurs à virgule flottante double précision.
Lorsqu’il est utilisé avec une valeur Single, le spécificateur de format "G9" garantit les allers-retours de la valeur Single originale. En effet, Single est un nombre à virgule flottante simple précision (binary32) et conforme à la norme IEEE 754-2008, qui offre jusqu’à neuf chiffres de précision. Pour des raisons de performances, nous vous recommandons de l’utiliser à la place du spécificateur de format "R".
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 à 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
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 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 :
double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1",
CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7
int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7
int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7
Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0
Spécificateur de format de 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 :
double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P",
CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %
Spécificateur de format aller-retour (R)
Le spécificateur de format aller-retour ("R") tente de garantir qu'une valeur numérique qui est convertie en chaîne est de nouveau analysée en aboutissant à la même valeur numérique. Ce format est pris en charge uniquement pour les types Half, Single, Double et BigInteger.
Dans .NET Framework et dans les versions de .NET Core antérieures à 3.0, le spécificateur de format « R » ne parvient pas à effectuer un aller-retour des valeurs Double dans certains cas. Pour les valeurs Double et Single, le format « R » offre également des performances relativement faibles. Nous vous recommandons plutôt d’utiliser le spécificateur de format "G17" pour les valeurs Double, et le spécificateur de format "G9" pour garantir l’aller-retour des valeurs Single.
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.
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 une valeur BigInteger avec le spécificateur de format aller-retour.
#using <System.Numerics.dll>
using namespace System;
using namespace System::Numerics;
void main()
{
BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
// 85070591730234615847396907784232501249
using System;
using System.Numerics;
public class Example
{
public static void Main()
{
var value = BigInteger.Pow(Int64.MaxValue, 2);
Console.WriteLine(value.ToString("R"));
}
}
// The example displays the following output:
// 85070591730234615847396907784232501249
Imports System.Numerics
Module Example
Public Sub Main()
Dim value = BigInteger.Pow(Int64.MaxValue, 2)
Console.WriteLine(value.ToString("R"))
End Sub
End Module
' The example displays the following output:
' 85070591730234615847396907784232501249
Important
Dans certains cas, les valeurs Double mises en forme avec la chaîne de format numérique standard "R" ne font pas un aller-retour correct si elles sont compilées avec les commutateurs /platform:x64 ou /platform:anycpu, et exécutées sur des systèmes 64 bits. Pour plus d'informations, consultez les paragraphes suivants :
Pour contourner le problème des valeurs Double mises en forme avec la chaîne de format numérique standard « R » et pour lesquelles l’aller-retour ne fonctionne pas correctement dans le cas d’une compilation avec les indicateurs /platform:x64 ou /platform:anycpu et d’une exécution sur des systèmes 64 bits, vous pouvez mettre en forme ces valeurs Double en utilisant la chaîne de format numérique standard « G17 ». L’exemple suivant utilise la chaîne de format « R » avec une valeur Double qui n’effectue pas un aller-retour avec succès. Il utilise également la chaîne de format « G17 » pour effectuer un aller-retour avec succès avec 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("{0:R} = {1:R}: {2}\n",
initialValue, roundTripped, initialValue.Equals(roundTripped));
Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
// Attempting to round-trip a Double with 'R':
// 0.6822871999174 = 0.68228719991740006: False
//
// Attempting to round-trip a Double with 'G17':
// 0.6822871999174 = 0.6822871999174: True
Imports System.Globalization
Module Example
Public Sub Main()
Console.WriteLine("Attempting to round-trip a Double with 'R':")
Dim initialValue As Double = 0.6822871999174
Dim valueString As String = initialValue.ToString("R",
CultureInfo.InvariantCulture)
Dim roundTripped As Double = Double.Parse(valueString,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped, initialValue.Equals(roundTripped))
Console.WriteLine()
Console.WriteLine("Attempting to round-trip a Double with 'G17':")
Dim valueString17 As String = initialValue.ToString("G17",
CultureInfo.InvariantCulture)
Dim roundTripped17 As Double = double.Parse(valueString17,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped17, initialValue.Equals(roundTripped17))
End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
' Attempting to round-trip a Double with 'R':
' 0.6822871999174 = 0.68228719991740006: False
'
' Attempting to round-trip a Double with 'G17':
' 0.6822871999174 = 0.6822871999174: True
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.
int value;
value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E
value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15
int value;
value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E
value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer
value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E
value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15
Notes
Cette section contient des informations supplémentaires sur l’utilisation de chaînes de format numériques 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 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 en cours qui fournit des valeurs utilisées pour indiquer 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(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(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 actuelle 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.
Notes
Pour plus d'informations sur la personnalisation des modèles ou des chaînes utilisés dans la mise en forme des valeurs numériques, consultez la rubrique de la classe NumberFormatInfo.
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, Half, Single et Double.
Infinis à virgule flottante et NaN
Quelle que soit la chaîne de format, si la valeur d’un type à virgule flottante Half, 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 respective qui est spécifiée par l’objet NumberFormatInfo actuellement applicable.
Exemple de code
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 produit des résultats similaires pour tout type numérique de base (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, Half et Single).
// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");
// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}",
floating.ToString("C", ci)); // Displays "C: $10,761.94"
Console.WriteLine("E: {0}",
floating.ToString("E03", ci)); // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}",
floating.ToString("F04", ci)); // Displays "F: 10761.9376"
Console.WriteLine("G: {0}",
floating.ToString("G", ci)); // Displays "G: 10761.937554"
Console.WriteLine("N: {0}",
floating.ToString("N03", ci)); // Displays "N: 10,761.938"
Console.WriteLine("P: {0}",
(floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}",
floating.ToString("R", ci)); // Displays "R: 10761.937554"
Console.WriteLine();
// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}",
integral.ToString("C", ci)); // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
integral.ToString("D6", ci)); // Displays "D: 008395"
Console.WriteLine("E: {0}",
integral.ToString("E03", ci)); // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}",
integral.ToString("F01", ci)); // Displays "F: 8395.0"
Console.WriteLine("G: {0}",
integral.ToString("G", ci)); // Displays "G: 8395"
Console.WriteLine("N: {0}",
integral.ToString("N01", ci)); // Displays "N: 8,395.0"
Console.WriteLine("P: {0}",
(integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
integral.ToString("X", ci)); // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On
Imports System.Globalization
Imports System.Threading
Module NumericFormats
Public Sub Main()
' Display string representations of numbers for en-us culture
Dim ci As New CultureInfo("en-us")
' Output floating point values
Dim floating As Double = 10761.937554
Console.WriteLine("C: {0}", _
floating.ToString("C", ci)) ' Displays "C: $10,761.94"
Console.WriteLine("E: {0}", _
floating.ToString("E03", ci)) ' Displays "E: 1.076E+004"
Console.WriteLine("F: {0}", _
floating.ToString("F04", ci)) ' Displays "F: 10761.9376"
Console.WriteLine("G: {0}", _
floating.ToString("G", ci)) ' Displays "G: 10761.937554"
Console.WriteLine("N: {0}", _
floating.ToString("N03", ci)) ' Displays "N: 10,761.938"
Console.WriteLine("P: {0}", _
(floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
Console.WriteLine("R: {0}", _
floating.ToString("R", ci)) ' Displays "R: 10761.937554"
Console.WriteLine()
' Output integral values
Dim integral As Integer = 8395
Console.WriteLine("C: {0}", _
integral.ToString("C", ci)) ' Displays "C: $8,395.00"
Console.WriteLine("D: {0}", _
integral.ToString("D6")) ' Displays "D: 008395"
Console.WriteLine("E: {0}", _
integral.ToString("E03", ci)) ' Displays "E: 8.395E+003"
Console.WriteLine("F: {0}", _
integral.ToString("F01", ci)) ' Displays "F: 8395.0"
Console.WriteLine("G: {0}", _
integral.ToString("G", ci)) ' Displays "G: 8395"
Console.WriteLine("N: {0}", _
integral.ToString("N01", ci)) ' Displays "N: 8,395.0"
Console.WriteLine("P: {0}", _
(integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}", _
integral.ToString("X", ci)) ' Displays "X: 0x20CB"
Console.WriteLine()
End Sub
End Module
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour