Note
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier les répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de changer de répertoire.
Cet article fournit des remarques supplémentaires à la documentation de référence de cette API.
Importante
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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient 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 (référence C#) et chaînes interpolées (référence Visual Basic).
Exemples
De nombreux exemples qui appellent la méthode Format sont répartis 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 le formatage de la sortie
Contrôle de la mise en forme
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
Commencez avec 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} dans la 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 non plus à vous soucier de la surcharge que vous appelez. Le compilateur sélectionne celle qui vous convient.
Contrôler la mise en forme
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'
De nombreux 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), les intervalles de temps (chaînes de format standard et personnalisées), tous les types d’énumération 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
Contrôler l’alignement
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 de mise en forme composite .
Quelle méthode dois-je appeler ?
| Objectif | Méthode à 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. C’est pourquoi vous n’avez pas besoin de déterminer laquelle des surcharges Format vous envisagez 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. C’est pourquoi vous n’avez pas besoin de déterminer la surcharge Format spécifique 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 paramètre provider. 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 méthode Format 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[,width][:formatString]}
Les crochets indiquent les éléments facultatifs. Les accolades d’ouverture et de fermeture sont requises. (Pour inclure une accolade textuelle ouvrante ou fermante dans la chaîne de format, consultez la section Échappement des accolades dans l’article La 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.
width
Optionnel. 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 width, 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 est width inférieure à la longueur de l’argument à insérer, width elle est ignorée et la longueur de la représentation sous forme de chaîne de l’argument est utilisée comme largeur de champ.
formatString
Optionnel. 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. (Consultez les chaînes de format numérique standard et les chaînes de format numérique personnalisées.)
DateTime et DateTimeOffset. (Consultez les chaînes de format de date et d’heure standard et les 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.)
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, tout type personnalisé peut implémenter IFormattable ou étendre l’implémentation d’un IFormattable type existant.
L’exemple suivant utilise les arguments width et formatString 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’une NullReferenceException pour les arguments null.Si vous appelez la surcharge Format(IFormatProvider, String, Object[]) et que l’implémentation
providerde l’objet IFormatProvider.GetFormat retourne une implémentation ICustomFormatter non nulle, l’argument est transmis à sa méthode ICustomFormatter.Format(String, Object, IFormatProvider). Si l’élément de format inclut unformatStringargument, 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 paramètres
ToStringde 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 peut inclure plus d’éléments de format que d’arguments, à condition que plusieurs éléments de format aient 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 dans leurs représentations en chaînes à l’aide des conventions de la culture actuelle, qui est retournée par la propriété CultureInfo.CurrentCulture. Vous pouvez contrôler ce comportement en appelant l’une des surcharges de Format qui incluent un paramètre provider. 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 méthode GetFormat se renvoie elle-même.
- NumberFormatInfo, qui est utilisé pour la mise en forme propre à la culture des valeurs numériques. Sa méthode GetFormat(Type) se renvoie elle-même.
Opérations de mise en forme personnalisées
Vous pouvez également appeler l’une des surcharges de la méthode Format qui ont un paramètre provider de type IFormatProvider afin d’effectuer des opérations personnalisées de mise en forme. 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 argument provider doit implémenter à la fois les interfaces IFormatProvider et ICustomFormatter. Lorsque la méthode Format reçoit une implémentation ICustomFormatter en tant qu'argument provider, la méthode Format appelle son implémentation IFormatProvider.GetFormat et demande un objet de type ICustomFormatter. Il appelle ensuite la méthode ICustomFormatter de l’objet Format retourné pour mettre en forme chaque élément de format dans la chaîne composite qui lui est transmise.
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 ICustomFormatter et IFormatProvider pour effectuer deux opérations :
- Il affiche les paramètres transmis à son implémentation ICustomFormatter.Format. 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
Questions fréquentes (FAQ)
Pourquoi recommandez-vous l’interpolation de chaîne plutôt que d'appeler la méthode String.Format ?
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 Format ou une autre méthode qui prend en charge la mise en forme composite, comme 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 plus faciles à coder et à lire. Les chaînes interpolées peuvent également être utilisées dans les opérations de concaténation de chaînes 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 les valeurs TimeSpan, consultez les chaînes de format TimeSpan standard et les chaînes de format TimeSpan personnalisées.
- Pour consulter les valeurs Guid, veuillez vous référer à la section Remarques de la page de référence Guid.ToString(String).
Comment 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[,width][: formatString]}
width 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 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 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 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 d’ouverture ou de fermeture est toujours interprétée comme le début ou la fin d’un élément de format. Pour être interprété littéralement, elle doit être placée dans une séquence d’échappement. Vous placez une accolade dans une séquence d’échappement 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 placées dans une séquence d’échappement 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 caractères résultante, 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 génère-t-il une 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 sans échappement déclenche également une 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($"{numbers} + {1} + {2} = {3}");
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($"{values} + {1} + {2} = {3}");
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
Collaborez avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner des problèmes et des demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
