Méthode System.String.Format
Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.
Important
Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).
Exemples
De nombreux exemples qui appellent la Format méthode sont entrelacés dans cet article. Vous pouvez également télécharger un ensemble complet d’exemples String.Format , qui sont inclus dans un projet .NET Core pour C#.
Voici quelques exemples inclus dans l’article :
Créer une chaîne de format
Insérer une chaîne
Élément de format
Mettre en forme les éléments qui ont le même index
Contrôler la sortie mise en forme
Mise en forme du contrôle
Espacement du contrôle
Alignement du contrôle
Contrôler le nombre de chiffres intégraux
Contrôler le nombre de chiffres après le séparateur décimal
Inclure des accolades littérales dans la chaîne de résultat
Rendre les chaînes de format sensibles à la culture
Rendre les chaînes de format sensibles à la culture
Personnaliser l’opération de mise en forme
Opération de mise en forme personnalisée
Un fournisseur d’interception et un formateur de chiffres romains
Prise en main de la méthode String.Format
Utilisez cette option String.Format si vous devez insérer la valeur d’un objet, d’une variable ou d’une expression dans une autre chaîne. Par exemple, vous pouvez insérer la valeur d’une Decimal valeur dans une chaîne pour l’afficher à l’utilisateur sous forme de chaîne unique :
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%s"
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0} per ounce.",
pricePerOunce)
' Result: The current price is 17.36 per ounce.
Vous pouvez également contrôler la mise en forme de cette valeur :
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%s"
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce)
' Result if current culture is en-US:
' The current price is $17.36 per ounce.
Outre la mise en forme, vous pouvez également contrôler l’alignement et l’espacement.
Insérer une chaîne
String.Format commence par une chaîne de format, suivie d’un ou plusieurs objets ou expressions qui seront convertis en chaînes et insérés à un emplacement spécifié dans la chaîne de format. Par exemple :
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%s"
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4D
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'
La {0} chaîne de format est un élément de format. 0 est l’index de l’objet dont la valeur de chaîne est insérée à cette position. (Les index commencent à 0.) Si l’objet à insérer n’est pas une chaîne, sa ToString méthode est appelée pour la convertir en une avant de l’insérer dans la chaîne de résultat.
Voici un autre exemple qui utilise deux éléments de format et deux objets dans la liste d’objets :
string s = String.Format("At {0}, the temperature is {1}°C.",
DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%s"
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Vous pouvez avoir autant d’éléments de mise en forme et autant d’objets dans la liste d’objets que vous le souhaitez, tant que l’index de chaque élément de format a un objet correspondant dans la liste d’objets. Vous n’avez pas à vous soucier de la surcharge que vous appelez ; le compilateur sélectionne celui qui vous convient.
Mise en forme du contrôle
Vous pouvez suivre l’index dans un élément de format avec une chaîne de format pour contrôler la façon dont un objet est mis en forme. Par exemple, {0:d} applique la chaîne de format « d » au premier objet de la liste d’objets. Voici un exemple avec un objet unique et deux éléments de format :
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%s"
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Un certain nombre de types prennent en charge les chaînes de format, y compris tous les types numériques (chaînes de format standard et personnalisées), toutes les dates et heures (chaînes de format standard et personnalisées) et les intervalles de temps (chaînes de format standard et personnalisées), tous les types d’énumération des types d’énumération et les GUID. Vous pouvez également ajouter la prise en charge des chaînes de format à vos propres types.
Espacement du contrôle
Vous pouvez définir la largeur de la chaîne insérée dans la chaîne de résultat à l’aide d’une syntaxe telle que {0,12}, qui insère une chaîne de 12 caractères. Dans ce cas, la représentation sous forme de chaîne du premier objet est alignée à droite dans le champ de 12 caractères. (Si la représentation sous forme de chaîne du premier objet est de plus de 12 caractères de longueur, cependant, la largeur de champ préférée est ignorée et la chaîne entière est insérée dans la chaîne de résultat.)
L’exemple suivant définit un champ de 6 caractères pour contenir la chaîne « Year » et certaines chaînes d’année, ainsi qu’un champ de 15 caractères pour contenir la chaîne « Population » et certaines données de population. Notez que les caractères sont alignés à droite dans le champ.
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));
Console.WriteLine(sb);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
open System
open System.Text
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore
printfn $"{sb}"
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
"Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
sb.AppendFormat("{0,6} {1,15:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
Alignement du contrôle
Par défaut, les chaînes sont alignées à droite dans leur champ si vous spécifiez une largeur de champ. Pour aligner à gauche les chaînes d’un champ, vous précédez la largeur du champ avec un signe négatif, par {0,-12} exemple pour définir un champ aligné à gauche de 12 caractères.
L’exemple suivant est similaire à celui précédent, sauf qu’il aligne à gauche les étiquettes et les données.
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for (int index = 0; index < years.Length; index++)
s += String.Format("{0,-10} {1,-10:N0}\n",
years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\n{s}"
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
"Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
s += String.Format("{0,-10} {1,-10:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
String.Format utilise la fonctionnalité de mise en forme composite. Pour plus d’informations, consultez Mise en forme composite.
Quelle méthode dois-je appeler ?
| Pour | Appeler |
|---|---|
| Mettez en forme un ou plusieurs objets à l’aide des conventions de la culture actuelle. | À l’exception des surcharges qui incluent un provider paramètre, les surcharges restantes Format incluent un String paramètre suivi d’un ou plusieurs paramètres d’objet. En raison de cela, vous n’avez pas besoin de déterminer la Format surcharge que vous avez l’intention d’appeler. Votre compilateur de langage sélectionne la surcharge appropriée parmi les surcharges qui n’ont pas de provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments comporte cinq arguments, le compilateur appelle la Format(String, Object[]) méthode. |
| Mettez en forme un ou plusieurs objets à l’aide des conventions d’une culture spécifique. | Chaque Format surcharge commençant par un provider paramètre est suivie d’un String paramètre et d’un ou plusieurs paramètres d’objet. En raison de cela, vous n’avez pas besoin de déterminer la surcharge spécifique Format que vous envisagez d’appeler. Votre compilateur de langage sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments comporte cinq arguments, le compilateur appelle la Format(IFormatProvider, String, Object[]) méthode. |
| Effectuez une opération de mise en forme personnalisée avec une ICustomFormatter implémentation ou une IFormattable implémentation. | L’une des quatre surcharges avec un provider paramètre. Le compilateur sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments. |
Méthode Format en bref
Chaque surcharge de la Format méthode utilise la fonctionnalité de mise en forme composite pour inclure des espaces réservés indexés de base zéro, appelés éléments de format, dans une chaîne de format composite. Au moment de l’exécution, chaque élément de format est remplacé par la représentation sous forme de chaîne de l’argument correspondant dans une liste de paramètres. Si la valeur de l’argument est null, l’élément de format est remplacé par String.Empty. Par exemple, l’appel suivant à la Format(String, Object, Object, Object) méthode inclut une chaîne de format avec trois éléments de format, {0}, {1}et {2}une liste d’arguments avec trois éléments.
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0);
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
open System
let dat = DateTime(2012, 1, 17, 9, 30, 0)
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// The example displays output like the following:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Dim dat As Date = #1/17/2012 9:30AM#
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
' At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Élément de format
Un élément de format a cette syntaxe :
{index[,alignment][:formatString]}
Les crochets indiquent les éléments facultatifs. Les accolades ouvrantes et fermante sont requises. (Pour inclure une accolade littérale ouvrante ou fermante dans la chaîne de format, consultez la sectionSection Échappant les accolades dans l’article De mise en forme composite.)
Par exemple, un élément de format pour mettre en forme une valeur monétaire peut apparaître comme suit :
var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);
open System
String.Format("{0,-10:C}", 126347.89m)
|> printfn "%s"
String.Format("{0,-10:C}", 126347.89D)
Un élément de format comporte les éléments suivants :
index
Index de base zéro de l’argument dont la représentation sous forme de chaîne doit être incluse à cette position dans la chaîne. Si cet argument est null, une chaîne vide est incluse à cette position dans la chaîne.
Alignement
facultatif. Entier signé qui indique la longueur totale du champ dans lequel l’argument est inséré et s’il est aligné à droite (entier positif) ou aligné à gauche (entier négatif). Si vous omettez l’alignement, la représentation sous forme de chaîne de l’argument correspondant est insérée dans un champ sans espaces de début ou de fin.
Si la valeur de l’alignement est inférieure à la longueur de l’argument à insérer, l’alignement est ignoré et la longueur de la représentation sous forme de chaîne de l’argument est utilisée comme largeur de champ.
formatString
facultatif. Chaîne qui spécifie le format de la chaîne de résultat de l’argument correspondant. Si vous omettez formatString, la méthode sans ToString paramètre de l’argument correspondant est appelée pour produire sa représentation sous forme de chaîne. Si vous spécifiez formatString, l’argument référencé par l’élément de format doit implémenter l’interface IFormattable . Les types qui prennent en charge les chaînes de format sont les suivants :
Tous les types intégraux et à virgule flottante. (Voir Chaînes de format numérique standard et chaînes de format numérique personnalisées.)
Voir DateTime et DateTimeOffset. (Voir Chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.)
Tous les types d’énumération. (Voir Chaînes de format d’énumération.)
des valeurs TimeSpan. (Voir Chaînes de format TimeSpan standard et chaînes de format TimeSpan personnalisées.)
GUID. (Voir la Guid.ToString(String) méthode.)
Toutefois, notez que n’importe quel type personnalisé peut implémenter IFormattable ou étendre l’implémentation d’un IFormattable type existant.
L’exemple suivant utilise les arguments et formatString les alignment arguments pour produire une sortie mise en forme.
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities =
{ Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277,
new DateTime(1950, 1, 1), 1970358),
Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995,
new DateTime(1950, 1, 1), 7891957),
Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808,
new DateTime(1950, 1, 1), 3620962),
Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452,
new DateTime(1950, 1, 1), 1849568) };
// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
"City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3)/ (double)city.Item3);
Console.WriteLine(output);
}
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities =
[ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
"New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
"Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
"Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]
// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"
for name, year1, pop1, year2, pop2 in cities do
String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
name, year1, pop1, year2, pop2,
double (pop2 - pop1) / double pop1)
|> printfn "%s"
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
Module Example3
Public Sub Main()
' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Dim cities() =
{Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),
Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),
Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568)}
' Display header
Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
"City", "Year", "Population", "Change (%)")
Console.WriteLine(header)
Console.WriteLine()
For Each city In cities
Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3) / city.Item3)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' City Year Population Year Population Change (%)
'
' Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
' New York 1940 7,454,995 1950 7,891,957 5.9 %
' Chicago 1940 3,396,808 1950 3,620,962 6.6 %
' Detroit 1940 1,623,452 1950 1,849,568 13.9 %
Mise en forme des arguments
Les éléments de format sont traités séquentiellement à partir du début de la chaîne. Chaque élément de format a un index qui correspond à un objet dans la liste d’arguments de la méthode. La Format méthode récupère l’argument et dérive sa représentation sous forme de chaîne comme suit :
Si l’argument est
null, la méthode insère String.Empty dans la chaîne de résultat. Vous n’avez pas à vous soucier de la gestion d’arguments NullReferenceException Null.Si vous appelez la Format(IFormatProvider, String, Object[]) surcharge et que l’implémentation de IFormatProvider.GetFormat l’objet
providerretourne une implémentation non nullICustomFormatter, l’argument est passé à sa ICustomFormatter.Format(String, Object, IFormatProvider) méthode. Si l’élément de format inclut un argument formatString , il est passé comme premier argument à la méthode. Si l’implémentation ICustomFormatter est disponible et produit une chaîne non null, cette chaîne est retournée en tant que représentation sous forme de chaîne de l’argument ; sinon, l’étape suivante s’exécute.Si l’argument implémente l’interface IFormattable , son IFormattable.ToString implémentation est appelée.
La méthode sans
ToStringparamètre de l’argument, qui remplace ou hérite d’une implémentation de classe de base, est appelée.
Pour obtenir un exemple qui intercepte les appels à la ICustomFormatter.Format méthode et vous permet de voir quelles informations la Format méthode passe à une méthode de mise en forme pour chaque élément de format dans une chaîne de format composite, voir Exemple : fournisseur d’interception et formateur de chiffres romains.
Pour plus d’informations, consultez Traitement de la commande.
Mettre en forme les éléments qui ont le même index
La Format méthode lève une FormatException exception si l’index d’un élément d’index est supérieur ou égal au nombre d’arguments dans la liste d’arguments. Toutefois, format vous pouvez inclure plus d’éléments de format qu’il existe des arguments, tant que plusieurs éléments de format ont le même index. Dans l’appel à la méthode dans l’exemple Format(String, Object) suivant, la liste d’arguments a un seul argument, mais la chaîne de format inclut deux éléments de format : l’un affiche la valeur décimale d’un nombre, et l’autre affiche sa valeur hexadécimale.
short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10} {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
string formatString = String.Format("{0,10:G}: {0,10:X}", value);
Console.WriteLine(formatString);
}
// The example displays the following output:
// Decimal Hex
//
// -32768: 8000
// -27: FFE5
// 0: 0
// 1042: 412
// 32767: 7FFF
open System
let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s %10s\n" "Decimal" "Hex"
for value in values do
String.Format("{0,10:G}: {0,10:X}", value)
|> printfn "%s"
// The example displays the following output:
// Decimal Hex
//
// -32768: 8000
// -27: FFE5
// 0: 0
// 1042: 412
// 32767: 7FFF
Module Example1
Public Sub Main()
Dim values() As Short = {Int16.MinValue, -27, 0, 1042, Int16.MaxValue}
Console.WriteLine("{0,10} {1,10}", "Decimal", "Hex")
Console.WriteLine()
For Each value As Short In values
Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
Console.WriteLine(formatString)
Next
End Sub
End Module
' The example displays the following output:
' Decimal Hex
'
' -32768: 8000
' -27: FFE5
' 0: 0
' 1042: 412
' 32767: 7FFF
Format et culture
En règle générale, les objets de la liste d’arguments sont convertis en représentations sous forme de chaînes à l’aide des conventions de la culture actuelle, qui est retournée par la CultureInfo.CurrentCulture propriété. Vous pouvez contrôler ce comportement en appelant l’une des surcharges qui Format incluent un provider paramètre. Le provider paramètre est une IFormatProvider implémentation qui fournit des informations de mise en forme personnalisées et propres à la culture utilisées pour modérer le processus de mise en forme.
L’interface IFormatProvider a un seul membre, GetFormatqui est chargé de renvoyer l’objet qui fournit des informations de mise en forme. .NET a trois IFormatProvider implémentations qui fournissent une mise en forme spécifique à la culture :
- CultureInfo. Sa GetFormat méthode retourne un objet propre à NumberFormatInfo la culture pour la mise en forme des valeurs numériques et un objet propre DateTimeFormatInfo à la culture pour la mise en forme des valeurs de date et d’heure.
- DateTimeFormatInfo, qui est utilisé pour la mise en forme propre à la culture des valeurs de date et d’heure. Sa GetFormat méthode se retourne.
- NumberFormatInfo, qui est utilisé pour la mise en forme propre à la culture des valeurs numériques. Sa GetFormat(Type) méthode se retourne.
Opérations de mise en forme personnalisées
Vous pouvez également appeler l’une des surcharges de la Format méthode qui ont un provider paramètre de type IFormatProvider pour effectuer des opérations de mise en forme personnalisées. Par exemple, vous pouvez mettre en forme un entier comme numéro d’identification ou comme numéro de téléphone. Pour effectuer une mise en forme personnalisée, votre provider argument doit implémenter à la fois les interfaces et ICustomFormatter les IFormatProvider interfaces. Lorsque la Format méthode est passée en ICustomFormatter tant qu’argument provider , la Format méthode appelle son IFormatProvider.GetFormat implémentation et demande un objet de type ICustomFormatter. Il appelle ensuite la méthode de l’objet Format retourné ICustomFormatter pour mettre en forme chaque élément de format dans la chaîne composite transmise à celui-ci.
Pour plus d’informations sur la fourniture de solutions de mise en forme personnalisées, consultez Guide pratique pour définir et utiliser des fournisseurs de formats numériques personnalisés et ICustomFormatter. Pour obtenir un exemple qui convertit des entiers en nombres personnalisés mis en forme, consultez Exemple : Une opération de mise en forme personnalisée. Pour obtenir un exemple qui convertit des octets non signés en chiffres romains, consultez Exemple : fournisseur d’interception et formateur de chiffres romains.
Exemple : une opération de mise en forme personnalisée
Cet exemple définit un fournisseur de format qui met en forme une valeur entière en tant que numéro de compte client au format x-xxxxx-xx.
using System;
public class TestFormatter
{
public static void Main()
{
int acctNumber = 79203159;
Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
try {
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
}
catch (FormatException e) {
Console.WriteLine(e.Message);
}
}
}
public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(string format,
object arg,
IFormatProvider formatProvider)
{
if (! this.Equals(formatProvider))
{
return null;
}
else
{
if (String.IsNullOrEmpty(format))
format = "G";
string customerString = arg.ToString();
if (customerString.Length < 8)
customerString = customerString.PadLeft(8, '0');
format = format.ToUpper();
switch (format)
{
case "G":
return customerString.Substring(0, 1) + "-" +
customerString.Substring(1, 5) + "-" +
customerString.Substring(6);
case "S":
return customerString.Substring(0, 1) + "/" +
customerString.Substring(1, 5) + "/" +
customerString.Substring(6);
case "P":
return customerString.Substring(0, 1) + "." +
customerString.Substring(1, 5) + "." +
customerString.Substring(6);
default:
throw new FormatException(
String.Format("The '{0}' format specifier is not supported.", format));
}
}
}
}
// The example displays the following output:
// 7-92031-59
// 7-92031-59
// 7/92031/59
// 7.92031.59
// The 'X' format specifier is not supported.
open System
type CustomerFormatter() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member this.Format(format, arg, formatProvider: IFormatProvider) =
if this.Equals formatProvider |> not then
null
else
let format =
if String.IsNullOrEmpty format then "G"
else format.ToUpper()
let customerString =
let s = string arg
if s.Length < 8 then
s.PadLeft(8, '0')
else s
match format with
| "G" ->
customerString.Substring(0, 1) + "-" +
customerString.Substring(1, 5) + "-" +
customerString.Substring 6
| "S" ->
customerString.Substring(0, 1) + "/" +
customerString.Substring(1, 5) + "/" +
customerString.Substring 6
| "P" ->
customerString.Substring(0, 1) + "." +
customerString.Substring(1, 5) + "." +
customerString.Substring 6
| _ ->
raise (FormatException $"The '{format}' format specifier is not supported.")
let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
String.Format(CustomerFormatter(), "{0:X}", acctNumber)
|> printfn "%s"
with :? FormatException as e ->
printfn $"{e.Message}"
// The example displays the following output:
// 7-92031-59
// 7-92031-59
// 7/92031/59
// 7.92031.59
// The 'X' format specifier is not supported.
Module TestFormatter
Public Sub Main()
Dim acctNumber As Integer = 79203159
Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
Try
Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
Catch e As FormatException
Console.WriteLine(e.Message)
End Try
End Sub
End Module
Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(type As Type) As Object _
Implements IFormatProvider.GetFormat
If type Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, _
arg As Object, _
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
If Not Me.Equals(formatProvider) Then
Return Nothing
Else
If String.IsNullOrEmpty(fmt) Then fmt = "G"
Dim customerString As String = arg.ToString()
if customerString.Length < 8 Then _
customerString = customerString.PadLeft(8, "0"c)
Select Case fmt
Case "G"
Return customerString.Substring(0, 1) & "-" & _
customerString.Substring(1, 5) & "-" & _
customerString.Substring(6)
Case "S"
Return customerString.Substring(0, 1) & "/" & _
customerString.Substring(1, 5) & "/" & _
customerString.Substring(6)
Case "P"
Return customerString.Substring(0, 1) & "." & _
customerString.Substring(1, 5) & "." & _
customerString.Substring(6)
Case Else
Throw New FormatException( _
String.Format("The '{0}' format specifier is not supported.", fmt))
End Select
End If
End Function
End Class
' The example displays the following output:
' 7-92031-59
' 7-92031-59
' 7/92031/59
' 7.92031.59
' The 'X' format specifier is not supported.
Exemple : un fournisseur d’interception et un formateur de chiffres romains
Cet exemple définit un fournisseur de format personnalisé qui implémente les interfaces et IFormatProvider les ICustomFormatter implémentations pour effectuer deux opérations :
Il affiche les paramètres passés à son ICustomFormatter.Format implémentation. Cela nous permet de voir quels paramètres la Format(IFormatProvider, String, Object[]) méthode passe à l’implémentation de mise en forme personnalisée pour chaque objet qu’elle tente de mettre en forme. Cela peut être utile lorsque vous déboguez votre application.
Si l’objet à mettre en forme est une valeur d’octet non signée qui doit être mise en forme à l’aide de la chaîne de format standard « R », le formateur personnalisé met en forme la valeur numérique en tant que chiffres romains.
using System;
using System.Globalization;
public class InterceptProvider : IFormatProvider, ICustomFormatter
{
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(String format, Object obj, IFormatProvider provider)
{
// Display information about method call.
string formatString = format ?? "<null>";
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider.GetType().Name, obj ?? "<null>", formatString);
if (obj == null) return String.Empty;
// If this is a byte and the "R" format string, format it with Roman numerals.
if (obj is Byte && formatString.ToUpper().Equals("R")) {
Byte value = (Byte) obj;
int remainder;
int result;
String returnString = String.Empty;
// Get the hundreds digit(s)
result = Math.DivRem(value, 100, out remainder);
if (result > 0)
returnString = new String('C', result);
value = (Byte) remainder;
// Get the 50s digit
result = Math.DivRem(value, 50, out remainder);
if (result == 1)
returnString += "L";
value = (Byte) remainder;
// Get the tens digit.
result = Math.DivRem(value, 10, out remainder);
if (result > 0)
returnString += new String('X', result);
value = (Byte) remainder;
// Get the fives digit.
result = Math.DivRem(value, 5, out remainder);
if (result > 0)
returnString += "V";
value = (Byte) remainder;
// Add the ones digit.
if (remainder > 0)
returnString += new String('I', remainder);
// Check whether we have too many X characters.
int pos = returnString.IndexOf("XXXX");
if (pos >= 0) {
int xPos = returnString.IndexOf("L");
if (xPos >= 0 & xPos == pos - 1)
returnString = returnString.Replace("LXXXX", "XC");
else
returnString = returnString.Replace("XXXX", "XL");
}
// Check whether we have too many I characters
pos = returnString.IndexOf("IIII");
if (pos >= 0)
if (returnString.IndexOf("V") >= 0)
returnString = returnString.Replace("VIIII", "IX");
else
returnString = returnString.Replace("IIII", "IV");
return returnString;
}
// Use default for all other formatting.
if (obj is IFormattable)
return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
else
return obj.ToString();
}
}
public class Example
{
public static void Main()
{
int n = 10;
double value = 16.935;
DateTime day = DateTime.Now;
InterceptProvider provider = new InterceptProvider();
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ",
(DayOfWeek) DateTime.Now.DayOfWeek));
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
}
}
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
open System
open System.Globalization
type InterceptProvider() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member _.Format(format, obj, provider: IFormatProvider) =
// Display information about method call.
let formatString =
if format = null then "<null>" else format
printfn $"Provider: {provider.GetType().Name}, Object: %A{obj}, Format String: %s{formatString}"
if obj = null then
String.Empty
else
// If this is a byte and the "R" format string, format it with Roman numerals.
match obj with
| :? byte as value when formatString.ToUpper().Equals "R" ->
let mutable returnString = String.Empty
// Get the hundreds digit(s)
let struct (result, remainder) = Math.DivRem(value, 100uy)
if result > 0uy then
returnString <- String('C', int result)
let value = byte remainder
// Get the 50s digit
let struct (result, remainder) = Math.DivRem(value, 50uy)
if result = 1uy then
returnString <- returnString + "L"
let value = byte remainder
// Get the tens digit.
let struct (result, remainder) = Math.DivRem(value, 10uy)
if result > 0uy then
returnString <- returnString + String('X', int result)
let value = byte remainder
// Get the fives digit.
let struct (result, remainder) = Math.DivRem(value, 5uy)
if result > 0uy then
returnString <- returnString + "V"
let value = byte remainder
// Add the ones digit.
if remainder > 0uy then
returnString <- returnString + String('I', int remainder)
// Check whether we have too many X characters.
let pos = returnString.IndexOf "XXXX"
if pos >= 0 then
let xPos = returnString.IndexOf "L"
returnString <-
if xPos >= 0 && xPos = pos - 1 then
returnString.Replace("LXXXX", "XC")
else
returnString.Replace("XXXX", "XL")
// Check whether we have too many I characters
let pos = returnString.IndexOf "IIII"
if pos >= 0 then
returnString <-
if returnString.IndexOf "V" >= 0 then
returnString.Replace("VIIII", "IX")
else
returnString.Replace("IIII", "IV")
returnString
// Use default for all other formatting.
| :? IFormattable as x ->
x.ToString(format, CultureInfo.CurrentCulture)
| _ ->
string obj
let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
Imports System.Globalization
Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
Implements ICustomFormatter.Format
Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider, If(obj IsNot Nothing, obj, "<null>"), formatString)
If obj Is Nothing Then Return String.Empty
' If this is a byte and the "R" format string, format it with Roman numerals.
If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
Dim value As Byte = CByte(obj)
Dim remainder As Integer
Dim result As Integer
Dim returnString As String = String.Empty
' Get the hundreds digit(s)
result = Math.DivRem(value, 100, remainder)
If result > 0 Then returnString = New String("C"c, result)
value = CByte(remainder)
' Get the 50s digit
result = Math.DivRem(value, 50, remainder)
If result = 1 Then returnString += "L"
value = CByte(remainder)
' Get the tens digit.
result = Math.DivRem(value, 10, remainder)
If result > 0 Then returnString += New String("X"c, result)
value = CByte(remainder)
' Get the fives digit.
result = Math.DivRem(value, 5, remainder)
If result > 0 Then returnString += "V"
value = CByte(remainder)
' Add the ones digit.
If remainder > 0 Then returnString += New String("I"c, remainder)
' Check whether we have too many X characters.
Dim pos As Integer = returnString.IndexOf("XXXX")
If pos >= 0 Then
Dim xPos As Integer = returnString.IndexOf("L")
If xPos >= 0 And xPos = pos - 1 Then
returnString = returnString.Replace("LXXXX", "XC")
Else
returnString = returnString.Replace("XXXX", "XL")
End If
End If
' Check whether we have too many I characters
pos = returnString.IndexOf("IIII")
If pos >= 0 Then
If returnString.IndexOf("V") >= 0 Then
returnString = returnString.Replace("VIIII", "IX")
Else
returnString = returnString.Replace("IIII", "IV")
End If
End If
Return returnString
End If
' Use default for all other formatting.
If obj Is GetType(IFormattable)
Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
Else
Return obj.ToString()
End If
End Function
End Class
Module Example
Public Sub Main()
Dim n As Integer = 10
Dim value As Double = 16.935
Dim day As DateTime = Date.Now
Dim provider As New InterceptProvider()
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today",
CType(Date.Now.DayOfWeek, DayOfWeek)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
CByte(2), CByte(12), CByte(199)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}",
CByte(2), CByte(12), CByte(199)))
End Sub
End Module
' The example displays the following output:
' Provider: InterceptProvider, Object: 10, Format String: N0
' Provider: InterceptProvider, Object: 16.935, Format String: C2
' Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
' 10: $16.94 on 1/31/2013
'
' Provider: InterceptProvider, Object: Today: , Format String: <null>
' Provider: InterceptProvider, Object: Thursday, Format String: F
' Today: : Thursday
'
' Provider: InterceptProvider, Object: 2, Format String: X
' Provider: InterceptProvider, Object: 12, Format String: <null>
' Provider: InterceptProvider, Object: 199, Format String: <null>
' 2, 12, 199
'
' Provider: InterceptProvider, Object: 2, Format String: R
' Provider: InterceptProvider, Object: 12, Format String: R
' Provider: InterceptProvider, Object: 199, Format String: R
' II, XII, CXCIX
FAQ
Pourquoi recommander l’interpolation de chaîne sur les appels à la String.Format méthode ?
L’interpolation de chaîne est la suivante :
Plus flexible. Elle peut être utilisée dans n’importe quelle chaîne sans nécessiter d’appel à une méthode prenant en charge la mise en forme composite. Sinon, vous devez appeler la méthode ou une autre méthode qui prend en charge la Format mise en forme composite, telle que Console.WriteLine ou StringBuilder.AppendFormat.
Plus lisible. Étant donné que l’expression à insérer dans une chaîne apparaît dans l’expression interpolée plutôt que dans une liste d’arguments, les chaînes interpolées sont beaucoup plus faciles à coder et à lire. En raison de leur meilleure lisibilité, les chaînes interpolées peuvent remplacer non seulement les appels aux méthodes de format composite, mais elles peuvent également être utilisées dans les opérations de concaténation de chaîne pour produire du code plus concis et plus clair.
Une comparaison des deux exemples de code suivants illustre la supériorité des chaînes interpolées sur la concaténation de chaînes et les appels aux méthodes de mise en forme composite. L’utilisation de plusieurs opérations de concaténation de chaîne dans l’exemple suivant produit du code détaillé et difficile à lire.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6];
output += "\n";
var date = DateTime.Now;
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
date, date.DayOfWeek);
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output =
names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6] + "\n"
let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example12
Public Sub Main()
Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " +
names(3) + ", " + names(4) + ", " + names(5) + ", " +
names(6)
output += vbCrLf
Dim dat = DateTime.Now
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
dat, dat.DayOfWeek)
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
En revanche, l’utilisation de chaînes interpolées dans l’exemple suivant produit un code beaucoup plus clair et plus concis que l’instruction de concaténation de chaîne et l’appel à la Format méthode dans l’exemple précédent.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " +
$"{names[5]}, {names[6]}";
var date = DateTime.Now;
output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, {names[5]}, {names[6]}"
let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s"
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example13
Public Sub Main()
Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " +
$"{names(5)}, {names(6)}"
Dim dat = DateTime.Now
output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}."
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Où puis-je trouver les chaînes de format prédéfinies ?
Pour tous les types intégraux et à virgule flottante, consultez Chaînes de format numérique standard et chaînes de format numérique personnalisées.
Pour connaître les valeurs de date et d’heure, consultez Chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.
Pour connaître les valeurs d’énumération, consultez Chaînes de format d’énumération.
Pour connaître TimeSpan les valeurs, consultez Chaînes de format TimeSpan standard et Chaînes de format TimeSpan personnalisées.
Pour connaître Guid les valeurs, consultez la section Remarques de la Guid.ToString(String) page de référence.
Comment faire contrôler l’alignement des chaînes de résultat qui remplacent les éléments de format ?
La syntaxe générale d’un élément de format est la suivante :
{index[,alignment][: formatString]}
où l’alignement est un entier signé qui définit la largeur du champ. Si cette valeur est négative, le texte du champ est aligné à gauche. S’il est positif, le texte est aligné à droite.
Comment faire contrôler le nombre de chiffres après le séparateur décimal ?
Toutes les chaînes de format numérique standard, à l’exception de « D » (utilisée uniquement avec des entiers), « G », « R » et « X » permettent un spécificateur de précision qui définit le nombre de chiffres décimaux dans la chaîne de résultat. L’exemple suivant utilise des chaînes de format numérique standard pour contrôler le nombre de chiffres décimaux dans la chaîne de résultat.
object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values)
{
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}\n",
Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
Console.WriteLine(result);
}
// The example displays output like the following:
// $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
//
// $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
//
// $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
open System
let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}\n", Convert.ToDouble(value), Convert.ToDouble(value) / 10000.)
|> printfn "%s"
// The example displays output like the following:
// $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
//
// $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
//
// $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
Module Example7
Public Sub Main()
Dim values() As Object = {1603, 1794.68235, 15436.14}
Dim result As String
For Each value In values
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}",
value, CDbl(value) / 10000)
Console.WriteLine(result)
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
'
' $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
'
' $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
Si vous utilisez une chaîne de format numérique personnalisée, utilisez le spécificateur de format « 0 » pour contrôler le nombre de chiffres décimaux dans la chaîne de résultat, comme l’illustre l’exemple suivant.
decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
Module Example8
Public Sub Main()
Dim value As Decimal = 16309.5436D
Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16309.54360 16,309.54 16309.544
Comment faire contrôler le nombre de chiffres intégraux ?
Par défaut, les opérations de mise en forme affichent uniquement des chiffres intégral non nuls. Si vous mettez en forme des entiers, vous pouvez utiliser un spécificateur de précision avec les chaînes de format standard « D » et « X » pour contrôler le nombre de chiffres.
int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
// 001326 0000052E
open System
let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// The example displays the following output:
// 001326 0000052E
Module Example10
Public Sub Main()
Dim value As Integer = 1326
Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 001326 0000052E
Vous pouvez remplir un nombre entier ou à virgule flottante avec des zéros de début pour produire une chaîne de résultat avec un nombre spécifié de chiffres intégraux à l’aide du spécificateur de format numérique personnalisé « 0 », comme l’illustre l’exemple suivant.
int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 00016342 00016342.000 0,000,016,342.0
open System
let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// The example displays the following output:
// 00016342 00016342.000 0,000,016,342.0
Module Example9
Public Sub Main()
Dim value As Integer = 16342
Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 00016342 00016342.000 0,000,016,342.0
Combien d’éléments puis-je inclure dans la liste de formats ?
Il n’y a pas de limite pratique. Le deuxième paramètre de la Format(IFormatProvider, String, Object[]) méthode est marqué avec l’attribut ParamArrayAttribute , ce qui vous permet d’inclure une liste délimitée ou un tableau d’objets en tant que liste de format.
Comment faire inclure des accolades littérales (« { » et « } ») dans la chaîne de résultat ?
Par exemple, comment empêcher l’appel de méthode suivant de lever une FormatException exception ?
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose);
let result =
String.Format("The text has {0} '{' characters and {1} '}' characters.", nOpen, nClose)
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose)
Une seule accolade ouvrante ou fermante est toujours interprétée comme le début ou la fin d’un élément de format. Pour être interprété littéralement, il doit être échappé. Vous échappez une accolade en ajoutant une autre accolade (« {{ » et « }} » au lieu de « { » et « } »), comme dans l’appel de méthode suivant :
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose);
Console.WriteLine(result);
let result =
String.Format("The text has {0} '{{' characters and {1} '}}' characters.", nOpen, nClose)
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose)
Toutefois, même les accolades échappées sont facilement mal interprétées. Nous vous recommandons d’inclure des accolades dans la liste de formats et d’utiliser des éléments de format pour les insérer dans la chaîne de résultat, comme l’illustre l’exemple suivant.
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}");
Console.WriteLine(result);
let result =
String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.", nOpen, "{", nClose, "}")
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}")
Pourquoi mon appel à la méthode String.Format lève-t-il une exception FormatException ?
La cause la plus courante de l’exception est que l’index d’un élément de format ne correspond pas à un objet dans la liste de formats. Cela indique généralement que vous avez mal numéroté les index des éléments de format ou que vous avez oublié d’inclure un objet dans la liste de formats. La tentative d’inclure un caractère d’accolade gauche ou droite non bouclage lève également un FormatException. Parfois, l’exception est le résultat d’une faute de frappe ; par exemple, une erreur classique consiste à mal typer « [ » (crochet gauche) au lieu de « { » (accolades gauche).
Si la méthode Format(System.IFormatProvider,System.String,System.Object[]) prend en charge les tableaux de paramètres, pourquoi mon code lève-t-il une exception lorsque j’utilise un tableau ?
Par exemple, le code suivant lève une FormatException exception :
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);
open System
let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
Imports System.Collections.Generic
Module Example5
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
End Sub
End Module
Il s’agit d’un problème de résolution de surcharge du compilateur. Étant donné que le compilateur ne peut pas convertir un tableau d’entiers en tableau d’objets, il traite le tableau d’entiers comme un seul argument, de sorte qu’il appelle la Format(String, Object) méthode. L’exception est levée, car il existe quatre éléments de format, mais seulement un seul élément dans la liste de formats.
Étant donné que Visual Basic ou C# ne peut pas convertir un tableau d’entiers en tableau d’objets, vous devez effectuer la conversion vous-même avant d’appeler la Format(String, Object[]) méthode. L’exemple suivant fournit une implémentation.
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);
open System
let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
Imports System.Collections.Generic
Module Example6
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Dim values(numbers.Length - 1) As Object
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
End Sub
End Module
