String.Format Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Convertit la valeur des objets en chaînes selon les formats spécifiés et les insère dans une autre chaîne.
Si vous découvrez la méthode String.Format, consultez la section Bien démarrer avec la méthode String.Format pour afficher une présentation rapide.
Consultez la section Notes afin d’obtenir une documentation générale sur la méthode String.Format.
Surcharges
| Format(IFormatProvider, String, Object, Object, Object) |
Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture. |
| Format(String, Object, Object, Object) |
Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. |
| Format(IFormatProvider, String, Object, Object) |
Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture. |
| Format(String, Object, Object) |
Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés. |
| Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>) |
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié. |
| Format(IFormatProvider, String, Object) |
Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant. Un paramètre fournit des informations de mise en forme propres à la culture. |
| Format(IFormatProvider, String, Object[]) |
Remplace les éléments de mise en forme d’une chaîne par les représentations sous forme de chaîne des objets correspondants dans un tableau spécifié. Un paramètre fournit des informations de mise en forme propres à la culture. |
| Format(String, Object[]) |
Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié. |
| Format(String, Object) |
Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié. |
| Format(IFormatProvider, CompositeFormat, Object[]) |
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié. |
| Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2) |
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié. |
| Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1) |
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié. |
| Format<TArg0>(IFormatProvider, CompositeFormat, TArg0) |
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié. |
Exemples
De nombreux exemples qui appellent la Format méthode sont interpersés dans la section Remarques de 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
Insertion d’une chaîne
Élément de format
Mettre en forme les éléments qui ont le même index
Sortie mise en forme du contrôle
Contrôle de la mise en forme
Contrôle de l’espacement
Contrôle de l’alignement
Contrôle du nombre de chiffres intégraux
Contrôle du nombre de chiffres après le séparateur décimal
Inclusion d’accolades littérales dans une chaîne de résultat
Rendre les chaînes de format sensibles à la culture
Mise en forme sensible à la culture
Personnaliser l’opération de mise en forme
Une opération de mise en forme personnalisée
Un fournisseur d’interception et un formateur de chiffres romains
Remarques
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).
Dans cette section :
Bien démarrer avec la méthode String.Format
Quelle méthode dois-je appeler ?
La méthode Format en bref
Élément Format
Mise en forme des arguments
Mettre en forme les éléments qui ont le même index
Mise en forme et culture
Opérations de mise en forme personnalisée
String.Format Q & A
Bien démarrer avec la méthode String.Format
Utilisez 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 la forme d’une chaîne unique :
Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
pricePerOunce);
// Result: The current price is 17.36 per ounce.
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.
Et vous pouvez contrôler la mise en forme de cette valeur :
Decimal pricePerOunce = (Decimal)17.36;
String^ s = 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.
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. Exemple :
Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
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.'
dans {0} la chaîne de format est un élément de format. 0 est l’index de l’objet dont la valeur de chaîne sera 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 le convertir en un objet 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);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
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 format et autant d’objets que vous le souhaitez dans la liste d’objets, 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 celui qui vous convient.
Mise en forme des contrôles
Vous pouvez suivre l’index dans un élément de format avec une chaîne de format pour contrôler la mise en forme d’un objet. 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);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
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é ), toutes les dates et heures (chaînes de format standard et personnalisé ) et les intervalles de temps (chaînes de format standard et personnalisé ), tous les types d’énumération de types d’énumération et les GUID. Vous pouvez également ajouter la prise en charge des chaînes de format à vos propres types.
Espacement de contrôle
Vous pouvez définir la largeur de la chaîne insérée dans la chaîne de résultat à l’aide de la 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 contient plus de 12 caractères, 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 « Année » 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.
array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
sb->AppendFormat("{0,6} {1,15:N0}\n",
years[index], population[index]);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
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 des contrôles
Par défaut, les chaînes sont alignées à droite dans leur champ si vous spécifiez une largeur de champ. Pour aligner des chaînes à gauche dans un champ, vous devez préfacer 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 au précédent, sauf qu’il aligne à gauche les étiquettes et les données.
array<int>^ years = { 2013, 2014, 2015 };
array<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]);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
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 ?
| À | Call |
|---|---|
| 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 paramètre suivi d’un String ou plusieurs paramètres d’objet. Pour cette raison, vous n’avez pas à déterminer la surcharge que 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 contient 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 qui commence par un provider paramètre est suivie d’un paramètre et d’un String ou plusieurs paramètres d’objet. Pour cette raison, 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 contient 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. |
La 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}, et une liste d’arguments avec trois éléments.
using namespace System;
void main()
{
DateTime^ dat = gcnew 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 the following output:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
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 la syntaxe suivante :
{index[,alignment][:formatString]}
Les crochets indiquent des éléments facultatifs. Les accolades ouvrantes et fermante sont requises. (Pour inclure une accolade ouvrante ou fermante littérale dans la chaîne de format, consultez la section Accolades d’échappement dans l’article Mise en forme composite .)
Par exemple, un élément de format pour mettre en forme une valeur monétaire peut ressembler à ceci :
String::Format("{0,-10:C}", (Decimal) 126347.89);
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 a la valeur null, une chaîne vide est incluse à cette position dans la chaîne.
Alignement
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 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
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. (Voir Chaînes de format numériques standard et Chaînes de format numériques personnalisées.)
Voir DateTime et DateTimeOffset. (Consultez 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. (Consultez 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 tout type personnalisé peut implémenter IFormattable ou étendre l’implémentation d’un IFormattable type existant.
L’exemple suivant utilise les alignment arguments et formatString pour produire une sortie mise en forme.
using namespace System;
void main()
{
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^>
{ gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277,
DateTime(1950, 1, 1), 1970358),
gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995,
DateTime(1950, 1, 1), 7891957),
gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808,
DateTime(1950, 1, 1), 3620962),
gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452,
DateTime(1950, 1, 1), 1849568) };
// Display header
String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
"City", "Year", "Population", "Change (%)");
Console::WriteLine(header);
String^ output;
for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
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 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 Example
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 s’insère String.Empty dans la chaîne de résultat. Vous n’avez pas à vous soucier de la gestion d’un NullReferenceException pour les arguments null.Si vous appelez la Format(IFormatProvider, String, Object[]) surcharge et que l’implémentation de l’objet
providerIFormatProvider.GetFormat retourne une implémentation non null ICustomFormatter , 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 transmet à une méthode de mise en forme pour chaque élément de format dans une chaîne de format composite, consultez Exemple : Fournisseur d’interception et formateur de chiffres romains.
Pour plus d’informations, consultez la section Ordre de traitement dans l’article Mise en forme composite .
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 qu’il n’y a d’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 contient un seul argument, mais la chaîne de format comprend deux éléments de format : l’un affiche la valeur décimale d’un nombre et l’autre 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 Example
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 leurs représentations sous forme de chaîne à 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 de Format qui inclut un provider paramètre. Le provider paramètre est une IFormatProvider implémentation qui fournit des informations de mise en forme personnalisées et spécifiques à la culture utilisées pour modérer le processus de mise en forme.
L’interface IFormatProvider a un seul membre, GetFormat, qui est chargé de retourner 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 renvoie un objet spécifique à NumberFormatInfo la culture pour la mise en forme des valeurs numériques et un objet spécifique à DateTimeFormatInfo la culture pour la mise en forme des valeurs de date et d’heure.
DateTimeFormatInfo, qui est utilisé pour la mise en forme spécifique à la culture des valeurs de date et d’heure. Sa GetFormat méthode retourne elle-même.
NumberFormatInfo, qui est utilisé pour la mise en forme spécifique à la culture des valeurs numériques. Sa GetFormat propriété retourne elle-même.
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 les IFormatProvider interfaces et ICustomFormatter . Lorsque la Format méthode est passée à une ICustomFormatter implémentation en 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 Format l’objet retourné ICustomFormatter pour mettre en forme chaque élément de format dans la chaîne composite qui lui est passée.
Pour plus d’informations sur la fourniture de solutions de mise en forme personnalisées, consultez How to: Define and Use Custom Numeric Format Providers 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 : Un fournisseur d’interception et un 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 namespace System;
ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
virtual Object^ GetFormat(Type^ formatType)
{
if (formatType == ICustomFormatter::typeid)
return this;
else
return nullptr;
}
virtual String^ Format(String^ format,
Object^ arg,
IFormatProvider^ formatProvider)
{
if (! this->Equals(formatProvider))
{
return nullptr;
}
else
{
if (String::IsNullOrEmpty(format))
format = "G";
String^ customerString = arg->ToString();
if (customerString->Length < 8)
customerString = customerString->PadLeft(8, '0');
format = format->ToUpper();
if (format == L"G")
return customerString->Substring(0, 1) + "-" +
customerString->Substring(1, 5) + "-" +
customerString->Substring(6);
else if (format == L"S")
return customerString->Substring(0, 1) + "/" +
customerString->Substring(1, 5) + "/" +
customerString->Substring(6);
else if (format == L"P")
return customerString->Substring(0, 1) + "." +
customerString->Substring(1, 5) + "." +
customerString->Substring(6);
else
throw gcnew FormatException(
String::Format("The '{0}' format specifier is not supported.", format));
}
}
};
void main()
{
int acctNumber = 79203159;
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
try {
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
}
catch (FormatException^ e) {
Console::WriteLine(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.
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 ICustomFormatter interfaces et IFormatProvider pour effectuer deux opérations :
Il affiche les paramètres passés à son ICustomFormatter.Format implémentation. Cela nous permet de voir les paramètres que la Format(IFormatProvider, String, Object[]) méthode transmet à 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 chiffres romains.
using namespace System;
using namespace System::Globalization;
ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
virtual Object^ GetFormat(Type^ formatType)
{
if (formatType == ICustomFormatter::typeid)
return this;
else
return nullptr;
}
virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider)
{
// Display information about method call.
String^ formatString = format != nullptr ? format : "<null>";
Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider, obj != nullptr ? obj : "<null>", formatString);
if (obj == nullptr) return String::Empty;
// If this is a byte and the "R" format string, format it with Roman numerals.
if (obj->GetType() == Byte::typeid && 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, remainder);
if (result > 0)
returnString = gcnew String('C', result);
value = (Byte) remainder;
// Get the 50s digit
result = Math::DivRem(value, 50, remainder);
if (result == 1)
returnString += "L";
value = (Byte) remainder;
// Get the tens digit.
result = Math::DivRem(value, 10, remainder);
if (result > 0)
returnString += gcnew String('X', result);
value = (Byte) remainder;
// Get the fives digit.
result = Math::DivRem(value, 5, remainder);
if (result > 0)
returnString += "V";
value = (Byte) remainder;
// Add the ones digit.
if (remainder > 0)
returnString += gcnew 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->GetType() == IFormattable::typeid)
return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
else
return obj->ToString();
}
};
void main()
{
int n = 10;
double value = 16.935;
DateTime day = DateTime::Now;
InterceptProvider^ provider = gcnew 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
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
String.Format Q & A
Pourquoi recommandez-vous l’interpolation de chaîne plutôt que les appels à la String.Format méthode ?
L’interpolation de chaîne est la suivante :
Plus flexible. Il peut être utilisé 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 Format méthode ou une autre méthode qui prend en charge la 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 plus grande 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î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 par rapport à la concaténation de chaînes et aux appels aux méthodes de mise en forme composite. L’utilisation de plusieurs opérations de concaténation de chaînes 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 Example
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 concis que l’instruction de concaténation de chaîne et l’appel de 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 Example
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 la liste des chaînes de format prédéfinies qui peuvent être utilisées avec les éléments de format ?
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 les TimeSpan valeurs, consultez Chaînes de format TimeSpan standard et Chaînes de format TimeSpan personnalisées.
Pour connaître les Guid 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ésultats 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 » (qui est utilisé avec des entiers uniquement), « G », « R » et « X » autorisent 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 Example
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 le montre 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 Example
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égraux 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 Example
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 pader 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 le montre 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 Example
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 comme 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 placé dans une séquence d’échappement. 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)
Cependant, 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 le montre 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 des formats. La tentative d’inclure un caractère d’accolade gauche ou droite non échiffé lève également un FormatException. Parfois, l’exception est le résultat d’une faute de frappe ; par exemple, une erreur typique consiste à mal taper « [ » (crochet gauche) au lieu de « { » (l’accolade 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 Example
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 argument unique, 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 un seul élément dans la liste des formats.
Étant donné que ni Visual Basic ni C# ne peuvent 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 Example
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
Format(IFormatProvider, String, Object, Object, Object)
Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2);static member Format : IFormatProvider * string * obj * obj * obj -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- String
- arg0
- Object
Premier objet à mettre en forme.
- arg1
- Object
Deuxième objet à mettre en forme.
- arg2
- Object
Troisième objet à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.
Exceptions
format a la valeur null.
format n'est pas valide.
- ou -
L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir trois expressions en représentations de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme sensible à la culture ou un formateur personnalisé. La méthode convertit chaque Object argument en sa représentation de chaîne en appelant sa méthode ToString(IFormatProvider) ou, si l’élément de format correspondant de l’objet inclut une chaîne de format, en appelant sa méthode ToString(String,IFormatProvider). Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
S’applique à
Format(String, Object, Object, Object)
Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);public static string Format (string format, object arg0, object arg1, object arg2);public static string Format (string format, object? arg0, object? arg1, object? arg2);static member Format : string * obj * obj * obj -> stringPublic Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As StringParamètres
- format
- String
- arg0
- Object
Premier objet à mettre en forme.
- arg1
- Object
Deuxième objet à mettre en forme.
- arg2
- Object
Troisième objet à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.
Exceptions
format a la valeur null.
format n'est pas valide.
- ou -
L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de trois expressions en leurs représentations sous forme de chaîne et pour incorporer ces représentations dans une chaîne.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
Exemple : Mettre en forme trois arguments
Cet exemple utilise la Format(String, Object, Object, Object) méthode pour créer une chaîne qui illustre le résultat d’une opération booléenne And avec deux valeurs entières. Notez que la chaîne de format comprend six éléments de mise en forme, mais que la méthode n’a que trois éléments dans sa liste de paramètres, car chaque élément est mis en forme de deux manières différentes.
using namespace System;
void main()
{
String^ formatString = " {0,10} ({0,8:X8})\n" +
"And {1,10} ({1,8:X8})\n" +
" = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
String^ result = String::Format(formatString,
value1, value2, value1 & value2);
Console::WriteLine(result);
}
// The example displays the following output:
// 16932 (00004224)
// And 15421 (00003C3D)
// = 36 (00000024)
string formatString = " {0,10} ({0,8:X8})\n" +
"And {1,10} ({1,8:X8})\n" +
" = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString,
value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
// 16932 (00004224)
// And 15421 (00003C3D)
// = 36 (00000024)
open System
let formatString =
" {0,10} ({0,8:X8})\nAnd {1,10} ({1,8:X8})\n = {2,10} ({2,8:X8})"
let value1 = 16932
let value2 = 15421
String.Format(formatString, value1, value2, value1 &&& value2)
|> printfn "%s"
// The example displays the following output:
// 16932 (00004224)
// And 15421 (00003C3D)
// = 36 (00000024)
Public Module Example
Public Sub Main()
Dim formatString As String = " {0,10} ({0,8:X8})" + vbCrLf + _
"And {1,10} ({1,8:X8})" + vbCrLf + _
" = {2,10} ({2,8:X8})"
Dim value1 As Integer = 16932
Dim value2 As Integer = 15421
Dim result As String = String.Format(formatString, _
value1, value2, value1 And value2)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16932 (00004224)
' And 15421 (00003C3D)
' = 36 (00000024)
Voir aussi
S’applique à
Format(IFormatProvider, String, Object, Object)
Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);public static string Format (IFormatProvider provider, string format, object arg0, object arg1);public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1);static member Format : IFormatProvider * string * obj * obj -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- String
- arg0
- Object
Premier objet à mettre en forme.
- arg1
- Object
Deuxième objet à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.
Exceptions
format a la valeur null.
format n'est pas valide.
- ou -
L’index d’un élément de format n’est pas zéro ou un.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir deux expressions en leurs représentations sous forme de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme sensible à la culture ou un formateur personnalisé. La méthode convertit chaque Object argument en sa représentation sous forme de chaîne en appelant sa méthode ToString(IFormatProvider) ou, si l’élément de format correspondant de l’objet inclut une chaîne de format, en appelant sa méthode ToString(String,IFormatProvider). Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
S’applique à
Format(String, Object, Object)
Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);public static string Format (string format, object arg0, object arg1);public static string Format (string format, object? arg0, object? arg1);static member Format : string * obj * obj -> stringPublic Shared Function Format (format As String, arg0 As Object, arg1 As Object) As StringParamètres
- format
- String
- arg0
- Object
Premier objet à mettre en forme.
- arg1
- Object
Deuxième objet à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.
Exceptions
format a la valeur null.
format n'est pas valide.
- ou -
L’index d’un élément de format n’est pas zéro ou un.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de deux expressions en leurs représentations sous forme de chaîne et pour incorporer ces représentations dans une chaîne.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
Exemple : Mettre en forme deux arguments
Cet exemple utilise la méthode pour afficher les Format(String, Object, Object) données de temps et de température stockées dans un objet générique Dictionary<TKey,TValue> . Notez que la chaîne de format comporte trois éléments de format, bien qu’il n’y ait que deux objets à mettre en forme. Cela est dû au fait que le premier objet de la liste (une valeur de date et d’heure) est utilisé par deux éléments de format : le premier élément de format affiche l’heure et le second affiche la date.
using namespace System;
using namespace System::Collections::Generic;
void main()
{
Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>();
temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
Console::WriteLine("Temperature Information:\n");
String^ output;
for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
{
output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F",
item->Key, item->Value);
Console::WriteLine(output);
}
}
// The example displays the following output:
// Temperature Information:
//
// Temperature at 2:00 PM on 6/1/2010: 87.5�F
// Temperature at 10:00 AM on 12/1/2010: 36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>();
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);
Console.WriteLine("Temperature Information:\n");
string output;
foreach (var item in temperatureInfo)
{
output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F",
item.Key, item.Value);
Console.WriteLine(output);
}
// The example displays output like the following:
// Temperature Information:
//
// Temperature at 2:00 PM on 6/1/2010: 87.5°F
// Temperature at 10:00 AM on 12/1/2010: 36.8°F
open System
open System.Collections.Generic
let temperatureInfo = Dictionary<DateTime, float>()
temperatureInfo.Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46)
temperatureInfo.Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81)
printfn $"Temperature Information:\n"
for item in temperatureInfo do
String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", item.Key, item.Value)
|> printfn "%s"
// The example displays output like the following:
// Temperature Information:
//
// Temperature at 2:00 PM on 6/1/2010: 87.5°F
// Temperature at 10:00 AM on 12/1/2010: 36.8°F
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim temperatureInfo As New Dictionary(Of Date, Double)
temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
Console.WriteLine("Temperature Information:")
Console.WriteLine()
Dim output As String
For Each item In temperatureInfo
output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
item.Key, item.Value)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' Temperature Information:
'
' Temperature at 2:00 PM on 6/1/2010: 87.5°F
' Temperature at 10:00 AM on 12/1/2010: 36.8°F
Voir aussi
- Mettre en forme des types dans .NET
- Mise en forme composite
- Chaînes de format de date et d'heure standard
- Chaînes de format de date et d’heure personnalisées
- Chaînes de format numériques standard
- Custom Numeric Format Strings
- Chaînes de format TimeSpan standard
- Chaînes de format TimeSpan personnalisées
- Enumeration Format Strings
S’applique à
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ReadOnlySpan<System::Object ^> args);public static string Format (IFormatProvider? provider, System.Text.CompositeFormat format, ReadOnlySpan<object?> args);static member Format : IFormatProvider * System.Text.CompositeFormat * ReadOnlySpan<obj> -> stringPublic Shared Function Format (provider As IFormatProvider, format As CompositeFormat, args As ReadOnlySpan(Of Object)) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- CompositeFormat
Un CompositeFormat.
- args
- ReadOnlySpan<Object>
Étendue d’objets à mettre en forme.
Retours
Chaîne mise en forme.
Exceptions
format a la valeur null.
L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.
S’applique à
Format(IFormatProvider, String, Object)
Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant. Un paramètre fournit des informations de mise en forme propres à la culture.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);public static string Format (IFormatProvider provider, string format, object arg0);public static string Format (IFormatProvider? provider, string format, object? arg0);static member Format : IFormatProvider * string * obj -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- String
- arg0
- Object
Objet à mettre en forme.
Retours
Copie de format dans laquelle le ou les éléments de mise en forme sont remplacés par la représentation sous forme de chaîne de arg0.
Exceptions
format a la valeur null.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur d’une expression en sa représentation sous forme de chaîne et pour incorporer cette représentation dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme sensible à la culture ou un formateur personnalisé. La méthode convertit arg0 en sa représentation sous forme de chaîne en appelant sa méthode ToString(IFormatProvider) ou, si l’élément de format correspondant de l’objet inclut une chaîne de format, en appelant sa méthode ToString(String,IFormatProvider). Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
S’applique à
Format(IFormatProvider, String, Object[])
Remplace les éléments de mise en forme d’une chaîne par les représentations sous forme de chaîne des objets correspondants dans un tableau spécifié. Un paramètre fournit des informations de mise en forme propres à la culture.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);public static string Format (IFormatProvider provider, string format, params object[] args);public static string Format (IFormatProvider? provider, string format, params object?[] args);static member Format : IFormatProvider * string * obj[] -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- String
- args
- Object[]
Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.
Exceptions
format ou args est null.
format n'est pas valide.
- ou -
L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir quatre expressions ou plus en leurs représentations de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme sensible à la culture ou un formateur personnalisé. La méthode convertit chaque Object argument en sa représentation de chaîne en appelant sa méthode ToString(IFormatProvider) ou, si l’élément de format correspondant de l’objet inclut une chaîne de format, en appelant sa méthode ToString(String,IFormatProvider). Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
Exemple : mise en forme sensible à la culture
Cet exemple utilise la Format(IFormatProvider, String, Object[]) méthode pour afficher la représentation sous forme de chaîne de certaines valeurs de date et d’heure et de valeurs numériques à l’aide de plusieurs cultures différentes.
string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };
DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
double value = 9164.32;
Console.WriteLine("Culture Date Value\n");
foreach (string cultureName in cultureNames)
{
System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(cultureName);
string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}",
culture.Name, dateToDisplay, value);
Console.WriteLine(output);
}
// The example displays the following output:
// Culture Date Value
//
// en-US Tuesday, September 01, 2009 9,164.32
// fr-FR mardi 1 septembre 2009 9 164,32
// de-DE Dienstag, 1. September 2009 9.164,32
// es-ES martes, 01 de septiembre de 2009 9.164,32
open System
open System.Globalization
let cultureNames = [| "en-US"; "fr-FR"; "de-DE"; "es-ES" |]
let dateToDisplay = DateTime(2009, 9, 1, 18, 32, 0)
let value = 9164.32
printfn "Culture Date Value\n"
for cultureName in cultureNames do
let culture = CultureInfo cultureName
String.Format(culture, "{0,-11} {1,-35:D} {2:N}", culture.Name, dateToDisplay, value)
|> printfn "%s"
// The example displays the following output:
// Culture Date Value
//
// en-US Tuesday, September 01, 2009 9,164.32
// fr-FR mardi 1 septembre 2009 9 164,32
// de-DE Dienstag, 1. September 2009 9.164,32
// es-ES martes, 01 de septiembre de 2009 9.164,32
Imports System.Globalization
Module Example
Public Sub Main()
Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
Dim dateToDisplay As Date = #9/1/2009 6:32PM#
Dim value As Double = 9164.32
Console.WriteLine("Culture Date Value")
Console.WriteLine()
For Each cultureName As String In cultureNames
Dim culture As New CultureInfo(cultureName)
Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
culture.Name, dateToDisplay, value)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' Culture Date Value
'
' en-US Tuesday, September 01, 2009 9,164.32
' fr-FR mardi 1 septembre 2009 9 164,32
' de-DE Dienstag, 1. September 2009 9.164,32
' es-ES martes, 01 de septiembre de 2009 9.164,32
Voir aussi
- DateTimeFormatInfo
- ICustomFormatter
- IFormatProvider
- NumberFormatInfo
- Mettre en forme des types dans .NET
- Mise en forme composite
- Chaînes de format de date et d'heure standard
- Chaînes de format de date et d’heure personnalisées
- Chaînes de format numériques standard
- Custom Numeric Format Strings
- Chaînes de format TimeSpan standard
- Chaînes de format TimeSpan personnalisées
- Enumeration Format Strings
S’applique à
Format(String, Object[])
Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié.
public:
static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);public static string Format (string format, params object[] args);public static string Format (string format, params object?[] args);static member Format : string * obj[] -> stringPublic Shared Function Format (format As String, ParamArray args As Object()) As StringParamètres
- format
- String
- args
- Object[]
Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.
Retours
Copie de format dans laquelle les éléments de mise en forme ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.
Exceptions
format ou args est null.
format n'est pas valide.
- ou -
L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de quatre expressions ou plus en leurs représentations de chaîne et pour incorporer ces représentations dans une chaîne. Étant donné que le args paramètre est marqué avec l’attribut System.ParamArrayAttribute , vous pouvez passer les objets à la méthode en tant qu’arguments individuels ou en tant que Object tableau.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
Exemple : Mettre en forme plus de trois arguments
Cet exemple crée une chaîne qui contient des données sur la température élevée et basse à une date particulière. La chaîne de format composite comporte cinq éléments de format dans l’exemple C# et six dans l’exemple Visual Basic. Deux des éléments de format définissent la largeur de la représentation de chaîne de leur valeur correspondante, et le premier élément de format inclut également une chaîne de format de date et d’heure standard.
using namespace System;
void main()
{
DateTime date1 = DateTime(2009, 7, 1);
TimeSpan hiTime = TimeSpan(14, 17, 32);
Decimal hiTemp = (Decimal) 62.1;
TimeSpan loTime = TimeSpan(3, 16, 10);
Decimal loTemp = (Decimal)54.8;
String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
date1, hiTime, hiTemp, loTime, loTemp);
Console::WriteLine(result1);
Console::WriteLine();
String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
Console::WriteLine(result2);
}
// The example displays the following output:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m;
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m;
string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
let date1 = DateTime(2009, 7, 1)
let hiTime = TimeSpan(14, 17, 32)
let hiTemp = 62.1m
let loTime = TimeSpan(3, 16, 10)
let loTemp = 54.8m
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", date1, hiTime, hiTemp, loTime, loTemp)
|> printfn "%s\n"
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", [| date1 :> obj; hiTime; hiTemp; loTime; loTemp |])
|> printfn "%s"
// The example displays output like the following:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
Module Example
Public Sub Main()
Dim date1 As Date = #7/1/2009#
Dim hiTime As New TimeSpan(14, 17, 32)
Dim hiTemp As Decimal = 62.1d
Dim loTime As New TimeSpan(3, 16, 10)
Dim loTemp As Decimal = 54.8d
Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
Console.WriteLine(result1)
Console.WriteLine()
Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
Console.WriteLine(result2)
End Sub
End Module
' The example displays the following output:
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
'
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
Vous pouvez également transmettre les objets à mettre en forme sous forme de tableau plutôt que de liste d’arguments.
using namespace System;
ref class CityInfo
{
public:
CityInfo(String^ name, int population, Decimal area, int year)
{
this->Name = name;
this->Population = population;
this->Area = area;
this->Year = year;
}
String^ Name;
int Population;
Decimal Area;
int Year;
};
ref class Example
{
public:
static void ShowPopulationData(CityInfo^ city)
{
array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet",
args);
Console::WriteLine(result);
}
};
void main()
{
CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
Example::ShowPopulationData(nyc2010);
CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);
Example::ShowPopulationData(sea2010);
}
// The example displays the following output:
// New York in 2010: Population 8,175,133, Area 302.6 sq. feet
// Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;
public class CityInfo
{
public CityInfo(String name, int population, Decimal area, int year)
{
this.Name = name;
this.Population = population;
this.Area = area;
this.Year = year;
}
public readonly String Name;
public readonly int Population;
public readonly Decimal Area;
public readonly int Year;
}
public class Example
{
public static void Main()
{
CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
ShowPopulationData(nyc2010);
CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);
ShowPopulationData(sea2010);
}
private static void ShowPopulationData(CityInfo city)
{
object[] args = { city.Name, city.Year, city.Population, city.Area };
String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet",
args);
Console.WriteLine(result);
}
}
// The example displays the following output:
// New York in 2010: Population 8,175,133, Area 302.6 sq. feet
// Seattle in 2010: Population 608,660, Area 83.9 sq. feet
open System
type CityInfo =
{ Name: string
Population: int
Area: Decimal
Year: int }
let showPopulationData city =
let args: obj[] = [| city.Name; city.Year; city.Population; city.Area |]
String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
|> printfn "%s"
{ Name = "New York"; Population = 8175133; Area = 302.64m; Year = 2010 }
|> showPopulationData
{ Name = "Seattle"; Population = 608660; Area = 83.94m; Year = 2010 }
|> showPopulationData
// The example displays the following output:
// New York in 2010: Population 8,175,133, Area 302.6 sq. feet
// Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
Me.Name = name
Me.Population = population
Me.Area = area
Me.Year = year
End Sub
Public ReadOnly Name As String
Public ReadOnly Population As Integer
Public ReadOnly Area As Decimal
Public ReadOnly Year As Integer
End Class
Module Example
Public Sub Main()
Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
ShowPopulationData(nyc2010)
Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)
ShowPopulationData(sea2010)
End Sub
Private Sub ShowPopulationData(city As CityInfo)
Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' New York in 2010: Population 8,175,133, Area 302.6 sq. feet
' Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Voir aussi
- Mettre en forme des types dans .NET
- Mise en forme composite
- Chaînes de format de date et d'heure standard
- Chaînes de format de date et d’heure personnalisées
- Chaînes de format numériques standard
- Custom Numeric Format Strings
- Chaînes de format TimeSpan standard
- Chaînes de format TimeSpan personnalisées
- Enumeration Format Strings
S’applique à
Format(String, Object)
Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0);public static string Format (string format, object arg0);public static string Format (string format, object? arg0);static member Format : string * obj -> stringPublic Shared Function Format (format As String, arg0 As Object) As StringParamètres
- format
- String
- arg0
- Object
Objet à mettre en forme.
Retours
Copie de format dans laquelle tous les éléments de mise en forme sont remplacés par la représentation sous forme de chaîne de arg0.
Exceptions
format a la valeur null.
L’élément de format dans format n’est pas valide.
- ou -
L’index d’un élément de format n’est pas zéro.
Remarques
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).
Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur d’une expression en sa représentation sous forme de chaîne et pour incorporer cette représentation dans une chaîne.
Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.
Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.
Exemple : Mise en forme d’un argument unique
L’exemple suivant utilise la méthode pour incorporer l’âge Format(String, Object) d’un individu au milieu d’une chaîne.
using namespace System;
void main()
{
DateTime birthdate = DateTime(1993, 7, 28);
array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16),
DateTime(1994, 7, 28),
DateTime(2000, 10, 16),
DateTime(2003, 7, 27),
DateTime(2007, 5, 27) };
for each (DateTime dateValue in dates)
{
TimeSpan interval = dateValue - birthdate;
// Get the approximate number of years, without accounting for leap years.
int years = ((int)interval.TotalDays) / 365;
// See if adding the number of years exceeds dateValue.
String^ output;
if (birthdate.AddYears(years) <= dateValue) {
output = String::Format("You are now {0} years old.", years);
Console::WriteLine(output);
}
else {
output = String::Format("You are now {0} years old.", years - 1);
Console::WriteLine(output);
}
}
}
// The example displays the following output:
// You are now 0 years old.
// You are now 1 years old.
// You are now 7 years old.
// You are now 9 years old.
// You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16),
new DateTime(1994, 7, 28),
new DateTime(2000, 10, 16),
new DateTime(2003, 7, 27),
new DateTime(2007, 5, 27) };
foreach (DateTime dateValue in dates)
{
TimeSpan interval = dateValue - birthdate;
// Get the approximate number of years, without accounting for leap years.
int years = ((int) interval.TotalDays) / 365;
// See if adding the number of years exceeds dateValue.
string output;
if (birthdate.AddYears(years) <= dateValue) {
output = String.Format("You are now {0} years old.", years);
Console.WriteLine(output);
}
else {
output = String.Format("You are now {0} years old.", years - 1);
Console.WriteLine(output);
}
}
// The example displays the following output:
// You are now 0 years old.
// You are now 1 years old.
// You are now 7 years old.
// You are now 9 years old.
// You are now 13 years old.
let birthdate = DateTime(1993, 7, 28)
let dates =
[ DateTime(1993, 8, 16)
DateTime(1994, 7, 28)
DateTime(2000, 10, 16)
DateTime(2003, 7, 27)
DateTime(2007, 5, 27) ]
for dateValue in dates do
let interval = dateValue - birthdate
// Get the approximate number of years, without accounting for leap years.
let years = (int interval.TotalDays) / 365
// See if adding the number of years exceeds dateValue.
if birthdate.AddYears years <= dateValue then
String.Format("You are now {0} years old.", years)
else
String.Format("You are now {0} years old.", years - 1)
|> printfn "%s"
// The example displays the following output:
// You are now 0 years old.
// You are now 1 years old.
// You are now 7 years old.
// You are now 9 years old.
// You are now 13 years old.
Module Example
Public Sub Main()
Dim birthdate As Date = #7/28/1993#
Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
#7/27/2003#, #5/27/2007# }
For Each dateValue As Date In dates
Dim interval As TimeSpan = dateValue - birthdate
' Get the approximate number of years, without accounting for leap years.
Dim years As Integer = CInt(interval.TotalDays) \ 365
' See if adding the number of years exceeds dateValue.
Dim output As String
If birthdate.AddYears(years) <= dateValue Then
output = String.Format("You are now {0} years old.", years)
Console.WriteLine(output)
Else
output = String.Format("You are now {0} years old.", years - 1)
Console.WriteLine(output)
End If
Next
End Sub
End Module
' The example displays the following output:
' You are now 0 years old.
' You are now 1 years old.
' You are now 7 years old.
' You are now 9 years old.
' You are now 13 years old.
Voir aussi
- Mettre en forme des types dans .NET
- Mise en forme composite
- Chaînes de format de date et d'heure standard
- Chaînes de format de date et d’heure personnalisées
- Chaînes de format numériques standard
- Custom Numeric Format Strings
- Chaînes de format TimeSpan standard
- Chaînes de format TimeSpan personnalisées
- Enumeration Format Strings
S’applique à
Format(IFormatProvider, CompositeFormat, Object[])
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ... cli::array <System::Object ^> ^ args);public static string Format (IFormatProvider? provider, System.Text.CompositeFormat format, params object?[] args);static member Format : IFormatProvider * System.Text.CompositeFormat * obj[] -> stringPublic Shared Function Format (provider As IFormatProvider, format As CompositeFormat, ParamArray args As Object()) As StringParamètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- CompositeFormat
Un CompositeFormat.
- args
- Object[]
Tableau d'objets à mettre en forme.
Retours
Chaîne mise en forme.
Exceptions
format ou args est null.
L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.
S’applique à
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié.
public:
generic <typename TArg0, typename TArg1, typename TArg2>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1, TArg2 arg2);public static string Format<TArg0,TArg1,TArg2> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1, TArg2 arg2);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 * 'TArg2 -> stringPublic Shared Function Format(Of TArg0, TArg1, TArg2) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1, arg2 As TArg2) As StringParamètres de type
- TArg0
Type du premier objet à mettre en forme.
- TArg1
Type du deuxième objet à mettre en forme.
- TArg2
Type du troisième objet à mettre en forme.
Paramètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- CompositeFormat
Un CompositeFormat.
- arg0
- TArg0
Premier objet à mettre en forme.
- arg1
- TArg1
Deuxième objet à mettre en forme.
- arg2
- TArg2
Troisième objet à mettre en forme.
Retours
Chaîne mise en forme.
Exceptions
format a la valeur null.
L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.
S’applique à
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié.
public:
generic <typename TArg0, typename TArg1>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1);public static string Format<TArg0,TArg1> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 -> stringPublic Shared Function Format(Of TArg0, TArg1) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1) As StringParamètres de type
- TArg0
Type du premier objet à mettre en forme.
- TArg1
Type du deuxième objet à mettre en forme.
Paramètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- CompositeFormat
Un CompositeFormat.
- arg0
- TArg0
Premier objet à mettre en forme.
- arg1
- TArg1
Deuxième objet à mettre en forme.
Retours
Chaîne mise en forme.
Exceptions
format a la valeur null.
L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.
S’applique à
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)
Remplace l’élément de format ou les éléments d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants au format spécifié.
public:
generic <typename TArg0>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0);public static string Format<TArg0> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 -> stringPublic Shared Function Format(Of TArg0) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0) As StringParamètres de type
- TArg0
Type du premier objet à mettre en forme.
Paramètres
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
- format
- CompositeFormat
Un CompositeFormat.
- arg0
- TArg0
Premier objet à mettre en forme.
Retours
Chaîne mise en forme.
Exceptions
format a la valeur null.
L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.