String.Format Méthode

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Convertit la valeur des objets en chaînes en fonction des formats spécifiés et les insère dans une autre chaîne.

Si vous débutez avec la String.Format méthode, consultez Prise en main de la méthode String.Format pour obtenir une vue d’ensemble rapide.

Surcharges

Nom	Description
Format(IFormatProvider, String, Object, Object, Object)	Remplace les éléments de format dans 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(IFormatProvider, String, Object, Object)	Remplace les éléments de format 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 format 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 dans une CompositeFormat représentation sous forme de chaîne des objets correspondants au format spécifié.
Format(IFormatProvider, CompositeFormat, Object[])	Remplace l’élément de format ou les éléments dans une CompositeFormat représentation sous forme de chaîne des objets correspondants au format spécifié.
Format(String, Object, Object, Object)	Remplace les éléments de format dans une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.
Format(IFormatProvider, String, Object[])	Remplace les éléments de format dans une chaîne par les représentations sous forme de chaîne d’objets correspondants dans un tableau spécifié. Un paramètre fournit des informations de mise en forme propres à la culture.
Format(IFormatProvider, String, Object)	Remplace l’élément de format ou les éléments 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(String, ReadOnlySpan<Object>)	Remplace l’élément de format dans une chaîne spécifiée par la représentation sous forme de chaîne d’un objet correspondant dans une étendue spécifiée.
Format(String, Object[])	Remplace l’élément de format dans 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 format dans une chaîne par la représentation sous forme de chaîne d’un objet spécifié.
Format(IFormatProvider, String, ReadOnlySpan<Object>)	Remplace les éléments de format dans une chaîne par les représentations sous forme de chaîne des objets correspondants dans une étendue spécifiée. Un paramètre fournit des informations de mise en forme propres à la culture.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	Remplace l’élément de format ou les éléments dans une CompositeFormat 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 dans une CompositeFormat 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 dans une CompositeFormat représentation sous forme de chaîne des objets correspondants au format spécifié.

Exemples

De nombreux exemples qui appellent la méthode Format sont répartis dans cet article. Vous pouvez également télécharger un ensemble complet d’exemples String.Format , qui sont inclus dans un projet .NET Core pour C#.

Voici quelques exemples inclus dans l’article :

Créer une chaîne de format

Insérer une chaîne
Élément de format
Mettre en forme les éléments qui ont le même index

Contrôler le formatage de la sortie

Contrôle de la mise en forme
Espacement du contrôle
Alignement du contrôle
Contrôler le nombre de chiffres intégraux
Contrôler le nombre de chiffres après le séparateur décimal
Inclure des accolades littérales dans la chaîne de résultat

Rendre les chaînes de format sensibles à la culture

Rendre les chaînes de format sensibles à la culture

Personnaliser l’opération de mise en forme

Opération de mise en forme personnalisée
Un fournisseur d’interception et un formateur de chiffres romains

Commencez avec la méthode String.Format

Utilisez cette option String.Format si vous devez insérer la valeur d’un objet, d’une variable ou d’une expression dans une autre chaîne. Par exemple, vous pouvez insérer la valeur d’une Decimal valeur dans une chaîne pour l’afficher à l’utilisateur sous forme de chaîne unique :

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.

let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%s"
// Result: The current price is 17.36 per ounce.

Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0} per ounce.",
                              pricePerOunce)
' Result: The current price is 17.36 per ounce.

Vous pouvez également contrôler la mise en forme de cette valeur :

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.

let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%s"
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.

Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                              pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

Outre la mise en forme, vous pouvez également contrôler l’alignement et l’espacement.

Insérer une chaîne

String.Format commence par une chaîne de format, suivie d’un ou plusieurs objets ou expressions qui seront convertis en chaînes et insérés à un emplacement spécifié dans la chaîne de format. Par exemple:

decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'

let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%s"
// Displays 'The temperature is 20.4°C.'

Dim temp As Decimal = 20.4D
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

La {0} dans la chaîne de format est un élément de format. 0 est l’index de l’objet dont la valeur de chaîne est insérée à cette position. (Les index commencent à 0.) Si l’objet à insérer n’est pas une chaîne, sa ToString méthode est appelée pour la convertir en une avant de l’insérer dans la chaîne de résultat.

Voici un autre exemple qui utilise deux éléments de format et deux objets dans la liste d’objets :

string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%s"
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                              Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

Vous pouvez avoir autant d’éléments de mise en forme et autant d’objets dans la liste d’objets que vous le souhaitez, tant que l’index de chaque élément de format a un objet correspondant dans la liste d’objets. Vous n’avez pas non plus à vous soucier de la surcharge que vous appelez. Le compilateur sélectionne celle qui vous convient.

Contrôler la mise en forme

Vous pouvez suivre l’index dans un élément de format avec une chaîne de format pour contrôler la façon dont un objet est mis en forme. Par exemple, {0:d} applique la chaîne de format « d » au premier objet de la liste d’objets. Voici un exemple avec un objet unique et deux éléments de format :

string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'

String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%s"
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Dim s As String = String.Format("It is now {0:d} at {0:t}",
                              Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

De nombreux types prennent en charge les chaînes de format, y compris tous les types numériques (chaînes de format standard et personnalisées), toutes les dates et heures (chaînes de format standard et personnalisées), les intervalles de temps (chaînes de format standard et personnalisées), tous les types d’énumération types d’énumération et les GUID. Vous pouvez également ajouter la prise en charge des chaînes de format à vos propres types.

Contrôler l'espacement

Vous pouvez définir la largeur de la chaîne insérée dans la chaîne de résultat à l’aide d’une syntaxe telle que {0,12}, qui insère une chaîne de 12 caractères. Dans ce cas, la représentation sous forme de chaîne du premier objet est alignée à droite dans le champ de 12 caractères. (Si la représentation sous forme de chaîne du premier objet est de plus de 12 caractères de longueur, cependant, la largeur de champ préférée est ignorée et la chaîne entière est insérée dans la chaîne de résultat.)

L’exemple suivant définit un champ de 6 caractères pour contenir la chaîne « Year » et certaines chaînes d’année, ainsi qu’un champ de 15 caractères pour contenir la chaîne « Population » et certaines données de population. Notez que les caractères sont alignés à droite dans le champ.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
    sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

Console.WriteLine(sb);

// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203

open System
open System.Text
 
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
   sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore

printfn $"{sb}"

// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203

Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                       "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
    sb.AppendFormat("{0,6} {1,15:N0}{2}",
                  years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

Contrôler l’alignement

Par défaut, les chaînes sont alignées à droite dans leur champ si vous spécifiez une largeur de champ. Pour aligner à gauche les chaînes d’un champ, vous précédez la largeur du champ avec un signe négatif, par {0,-12} exemple pour définir un champ aligné à gauche de 12 caractères.

L’exemple suivant est similaire à celui précédent, sauf qu’il aligne à gauche les étiquettes et les données.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for (int index = 0; index < years.Length; index++)
    s += String.Format("{0,-10} {1,-10:N0}\n",
                       years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
    s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\n{s}"
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                               "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
    s += String.Format("{0,-10} {1,-10:N0}{2}",
                     years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format utilise la fonctionnalité de mise en forme composite. Pour plus d’informations, consultez Mise en forme composite.

Quelle méthode dois-je appeler ?

Objective	Méthode à appeler
Mettez en forme un ou plusieurs objets à l’aide des conventions de la culture actuelle.	À l’exception des surcharges qui incluent un provider paramètre, les surcharges restantes Format incluent un String paramètre suivi d’un ou plusieurs paramètres d’objet. C’est pourquoi vous n’avez pas besoin de déterminer laquelle des surcharges Format vous envisagez d’appeler. Votre compilateur de langage sélectionne la surcharge appropriée parmi les surcharges qui n’ont pas de provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments comporte cinq arguments, le compilateur appelle la Format(String, Object[]) méthode.
Mettez en forme un ou plusieurs objets à l’aide des conventions d’une culture spécifique.	Chaque Format surcharge commençant par un provider paramètre est suivie d’un String paramètre et d’un ou plusieurs paramètres d’objet. C’est pourquoi vous n’avez pas besoin de déterminer la surcharge Format spécifique vous envisagez d’appeler. Votre compilateur de langage sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments comporte cinq arguments, le compilateur appelle la Format(IFormatProvider, String, Object[]) méthode.
Effectuez une opération de mise en forme personnalisée avec une ICustomFormatter implémentation ou une IFormattable implémentation.	L’une des quatre surcharges avec un paramètre provider. Le compilateur sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments.

Méthode Format en bref

Chaque surcharge de la méthode Format utilise la fonctionnalité de mise en forme composite pour inclure des espaces réservés indexés de base zéro, appelés éléments de format, dans une chaîne de format composite. Au moment de l’exécution, chaque élément de format est remplacé par la représentation sous forme de chaîne de l’argument correspondant dans une liste de paramètres. Si la valeur de l’argument est null, l’élément de format est remplacé par String.Empty. Par exemple, l’appel suivant à la Format(String, Object, Object, Object) méthode inclut une chaîne de format avec trois éléments de format, {0}, {1}et {2}une liste d’arguments avec trois éléments.

DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0);
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

open System

let dat = DateTime(2012, 1, 17, 9, 30, 0) 
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

Dim dat As Date = #1/17/2012 9:30AM#
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

Élément de format

Un élément de format a cette syntaxe :

{index[,width][:formatString]}

Les crochets indiquent les éléments facultatifs. Les accolades d’ouverture et de fermeture sont requises. (Pour inclure une accolade textuelle ouvrante ou fermante dans la chaîne de format, consultez la section Échappement des accolades dans l’article La mise en forme composite.)

Par exemple, un élément de format pour mettre en forme une valeur monétaire peut apparaître comme suit :

var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);

open System

String.Format("{0,-10:C}", 126347.89m)         
|> printfn "%s"

String.Format("{0,-10:C}", 126347.89D)

Un élément de format comporte les éléments suivants :

index
Index de base zéro de l’argument dont la représentation sous forme de chaîne doit être incluse à cette position dans la chaîne. Si cet argument est null, une chaîne vide est incluse à cette position dans la chaîne.

width
Optional. Entier signé qui indique la longueur totale du champ dans lequel l’argument est inséré et s’il est aligné à droite (entier positif) ou aligné à gauche (entier négatif). Si vous omettez width, la représentation sous forme de chaîne de l’argument correspondant est insérée dans un champ sans espaces de début ou de fin.

Si la valeur est width inférieure à la longueur de l’argument à insérer, width elle est ignorée et la longueur de la représentation sous forme de chaîne de l’argument est utilisée comme largeur de champ.

formatString
Optional. Chaîne qui spécifie le format de la chaîne de résultat de l’argument correspondant. Si vous omettez formatString, la méthode sans ToString paramètre de l’argument correspondant est appelée pour produire sa représentation sous forme de chaîne. Si vous spécifiez formatString, l’argument référencé par l’élément de format doit implémenter l’interface IFormattable . Les types qui prennent en charge les chaînes de format sont les suivants :

• Tous les types intégraux et à virgule flottante. (Consultez les chaînes de format numérique standard et les chaînes de format numérique personnalisées.)

• DateTime et DateTimeOffset. (Consultez les chaînes de format de date et d’heure standard et les chaînes de format de date et d’heure personnalisées.)

• Tous les types d’énumération. (Voir chaînes de format d’énumération.)

• Valeurs TimeSpan. (Voir chaînes de format TimeSpan standard et chaînes de format TimeSpan personnalisées.)

• GUID. (Voir la Guid.ToString(String) méthode.)

Toutefois, tout type personnalisé peut implémenter IFormattable ou étendre l’implémentation d’un IFormattable type existant.

L’exemple suivant utilise les arguments width et formatString pour produire une sortie mise en forme.

// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities =
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277,
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995,
                   new DateTime(1950, 1, 1), 7891957),
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808,
                   new DateTime(1950, 1, 1), 3620962),
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452,
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities = 
    [ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
      "New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
      "Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
      "Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]

// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"

for name, year1, pop1, year2, pop2 in cities do
    String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                  name, year1, pop1, year2, pop2,
                  double (pop2 - pop1) / double pop1)
    |> printfn "%s"
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Module Example4
    Public Sub Main()
        ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
        Dim cities() =
          {Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568)}

        ' Display header
        Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
        Console.WriteLine(header)
        Console.WriteLine()
        For Each city In cities
            Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3) / city.Item3)
            Console.WriteLine(output)
        Next
    End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Mise en forme des arguments

Les éléments de format sont traités séquentiellement à partir du début de la chaîne. Chaque élément de format a un index qui correspond à un objet dans la liste d’arguments de la méthode. La Format méthode récupère l’argument et dérive sa représentation sous forme de chaîne comme suit :

• Si l’argument est null, la méthode insère String.Empty dans la chaîne de résultat. Vous n’avez pas à vous soucier de la gestion d’une NullReferenceException pour les arguments null.

• Si vous appelez la surcharge Format(IFormatProvider, String, Object[]) et que l’implémentation provider de l’objet IFormatProvider.GetFormat retourne une implémentation ICustomFormatter non nulle, l’argument est transmis à sa méthode ICustomFormatter.Format(String, Object, IFormatProvider). Si l’élément de format inclut un formatString argument, il est passé comme premier argument à la méthode. Si l’implémentation ICustomFormatter est disponible et produit une chaîne non null, cette chaîne est retournée en tant que représentation sous forme de chaîne de l’argument ; sinon, l’étape suivante s’exécute.

• Si l’argument implémente l’interface IFormattable , son IFormattable.ToString implémentation est appelée.

• La méthode sans paramètres ToString de l’argument, qui remplace ou hérite d’une implémentation de classe de base, est appelée.

Pour obtenir un exemple qui intercepte les appels à la ICustomFormatter.Format méthode et vous permet de voir quelles informations la Format méthode passe à une méthode de mise en forme pour chaque élément de format dans une chaîne de format composite, voir Exemple : fournisseur d’interception et formateur de chiffres romains.

Pour plus d’informations, consultez Traitement de la commande.

Mettre en forme les éléments qui ont le même index

La Format méthode lève une FormatException exception si l’index d’un élément d’index est supérieur ou égal au nombre d’arguments dans la liste d’arguments. Toutefois, format peut inclure plus d’éléments de format que d’arguments, à condition que plusieurs éléments de format aient le même index. Dans l’appel à la méthode dans l’exemple Format(String, Object) suivant, la liste d’arguments a un seul argument, mais la chaîne de format inclut deux éléments de format : l’un affiche la valeur décimale d’un nombre, et l’autre affiche sa valeur hexadécimale.

short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
   string formatString = String.Format("{0,10:G}: {0,10:X}", value);
   Console.WriteLine(formatString);
}
// The example displays the following output:
//       Decimal         Hex
//
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

open System

let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s  %10s\n" "Decimal" "Hex"
for value in values do
    String.Format("{0,10:G}: {0,10:X}", value)
    |> printfn "%s"
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

Module Example1
    Public Sub Main()
        Dim values() As Short = {Int16.MinValue, -27, 0, 1042, Int16.MaxValue}
        Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
        Console.WriteLine()
        For Each value As Short In values
            Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
            Console.WriteLine(formatString)
        Next
    End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Format et culture

En règle générale, les objets de la liste d’arguments sont convertis dans leurs représentations en chaînes à l’aide des conventions de la culture actuelle, qui est retournée par la propriété CultureInfo.CurrentCulture. Vous pouvez contrôler ce comportement en appelant l’une des surcharges de Format qui incluent un paramètre provider. Le provider paramètre est une IFormatProvider implémentation qui fournit des informations de mise en forme personnalisées et propres à la culture utilisées pour modérer le processus de mise en forme.

L’interface IFormatProvider a un seul membre, GetFormatqui est chargé de renvoyer l’objet qui fournit des informations de mise en forme. .NET a trois IFormatProvider implémentations qui fournissent une mise en forme spécifique à la culture :

• CultureInfo. Sa GetFormat méthode retourne un objet propre à NumberFormatInfo la culture pour la mise en forme des valeurs numériques et un objet propre DateTimeFormatInfo à la culture pour la mise en forme des valeurs de date et d’heure.
• DateTimeFormatInfo, qui est utilisé pour la mise en forme propre à la culture des valeurs de date et d’heure. Sa méthode GetFormat se renvoie elle-même.
• NumberFormatInfo, qui est utilisé pour la mise en forme propre à la culture des valeurs numériques. Sa méthode GetFormat(Type) se renvoie elle-même.

Opérations de mise en forme personnalisées

Vous pouvez également appeler l’une des surcharges de la méthode Format qui ont un paramètre provider de type IFormatProvider afin d’effectuer des opérations personnalisées de mise en forme. Par exemple, vous pouvez mettre en forme un entier comme numéro d’identification ou comme numéro de téléphone. Pour effectuer une mise en forme personnalisée, votre argument provider doit implémenter à la fois les interfaces IFormatProvider et ICustomFormatter. Lorsque la méthode Format reçoit une implémentation ICustomFormatter en tant qu'argument provider, la méthode Format appelle son implémentation IFormatProvider.GetFormat et demande un objet de type ICustomFormatter. Il appelle ensuite la méthode ICustomFormatter de l’objet Format retourné pour mettre en forme chaque élément de format dans la chaîne composite qui lui est transmise.

Pour plus d’informations sur la fourniture de solutions de mise en forme personnalisées, consultez Guide pratique pour définir et utiliser des fournisseurs de formats numériques personnalisés et ICustomFormatter. Pour obtenir un exemple qui convertit des entiers en nombres personnalisés mis en forme, consultez Exemple : Une opération de mise en forme personnalisée. Pour obtenir un exemple qui convertit des octets non signés en chiffres romains, consultez Exemple : fournisseur d’interception et formateur de chiffres romains.

Exemple : une opération de mise en forme personnalisée

Cet exemple définit un fournisseur de format qui met en forme une valeur entière en tant que numéro de compte client au format x-xxxxx-xx.

using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType) 
   {
      if (formatType == typeof(ICustomFormatter))        
         return this; 
      else
         return null;
   }
   
   public string Format(string format, 
                         object arg, 
                         IFormatProvider formatProvider) 
   {                       
      if (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

open System

type CustomerFormatter() = 
    interface IFormatProvider with
        member this.GetFormat(formatType) =
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null

    interface ICustomFormatter with
        member this.Format(format, arg, formatProvider: IFormatProvider) = 
            if this.Equals formatProvider |> not then
                null
            else
                let format = 
                    if String.IsNullOrEmpty format then "G"
                    else format.ToUpper()
                
                let customerString = 
                    let s = string arg
                    if s.Length < 8 then
                        s.PadLeft(8, '0')
                    else s
                
                match format with
                | "G" ->
                    customerString.Substring(0, 1) + "-" +
                        customerString.Substring(1, 5) + "-" +
                        customerString.Substring 6
                | "S" ->                          
                    customerString.Substring(0, 1) + "/" +
                        customerString.Substring(1, 5) + "/" +
                        customerString.Substring 6
                | "P" ->                          
                    customerString.Substring(0, 1) + "." +
                        customerString.Substring(1, 5) + "." +
                        customerString.Substring 6
                | _ ->
                    raise (FormatException $"The '{format}' format specifier is not supported.")

let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
    String.Format(CustomerFormatter(), "{0:X}", acctNumber)
    |> printfn "%s"
with :? FormatException as e ->
    printfn $"{e.Message}"

// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, _
                           arg As Object, _
                           formatProvider As IFormatProvider) As String _
                    Implements ICustomFormatter.Format
      If Not Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

Exemple : un fournisseur d’interception et un formateur de chiffres romains

Cet exemple définit un fournisseur de format personnalisé qui implémente les interfaces ICustomFormatter et IFormatProvider pour effectuer deux opérations :

• Il affiche les paramètres transmis à son implémentation ICustomFormatter.Format. Cela nous permet de voir quels paramètres la Format(IFormatProvider, String, Object[]) méthode passe à l’implémentation de mise en forme personnalisée pour chaque objet qu’elle tente de mettre en forme. Cela peut être utile lorsque vous déboguez votre application.
• Si l’objet à mettre en forme est une valeur d’octet non signée qui doit être mise en forme à l’aide de la chaîne de format standard « R », le formateur personnalisé met en forme la valeur numérique en tant que chiffres romains.

using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(String format, Object obj, IFormatProvider provider)
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);

      if (obj == null) return String.Empty;

      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder;
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0)
            returnString += new String('I', remainder);

         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L");
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");

         return returnString;
      }

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class FormatExample12
{
   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 TypeOf obj Is IFormattable Then
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today",
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}",
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

FAQ

Pourquoi recommandez-vous l’interpolation de chaîne plutôt que d'appeler la méthode String.Format ?

L’interpolation de chaîne est la suivante :

• Plus flexible. Elle peut être utilisée dans n’importe quelle chaîne sans nécessiter d’appel à une méthode prenant en charge la mise en forme composite. Sinon, vous devez appeler la méthode Format ou une autre méthode qui prend en charge la mise en forme composite, comme Console.WriteLine ou StringBuilder.AppendFormat.
• Plus lisible. Étant donné que l’expression à insérer dans une chaîne apparaît dans l’expression interpolée plutôt que dans une liste d’arguments, les chaînes interpolées sont plus faciles à coder et à lire. Les chaînes interpolées peuvent également être utilisées dans les opérations de concaténation de chaînes pour produire du code plus concis et plus clair.

Une comparaison des deux exemples de code suivants illustre la supériorité des chaînes interpolées sur la concaténation de chaînes et les appels aux méthodes de mise en forme composite. L’utilisation de plusieurs opérations de concaténation de chaîne dans l’exemple suivant produit du code détaillé et difficile à lire.

string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = names[0] + ", " + names[1] + ", " + names[2] + ", " +
                names[3] + ", " + names[4] + ", " + names[5] + ", " +
                names[6];

output += "\n";
var date = DateTime.Now;
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
                        date, date.DayOfWeek);
Console.WriteLine(output);
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

open System

let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = 
    names[0] + ", " + names[1] + ", " + names[2] + ", " + 
    names[3] + ", " + names[4] + ", " + names[5] + ", " + 
    names[6] + "\n"

let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example12
    Public Sub Main()
        Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
        Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " +
                   names(3) + ", " + names(4) + ", " + names(5) + ", " +
                   names(6)

        output += vbCrLf
        Dim dat = DateTime.Now
        output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
                              dat, dat.DayOfWeek)
        Console.WriteLine(output)
    End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

En revanche, l’utilisation de chaînes interpolées dans l’exemple suivant produit un code beaucoup plus clair et plus concis que l’instruction de concaténation de chaîne et l’appel à la Format méthode dans l’exemple précédent.

string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " +
                $"{names[5]}, {names[6]}";

var date = DateTime.Now;
output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
Console.WriteLine(output);
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

open System

let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, {names[5]}, {names[6]}"  

let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s" 
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example13
    Public Sub Main()
        Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
        Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " +
                   $"{names(5)}, {names(6)}"

        Dim dat = DateTime.Now
        output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}."
        Console.WriteLine(output)
    End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Où puis-je trouver les chaînes de format prédéfinies ?

• Pour tous les types intégraux et à virgule flottante, consultez Chaînes de format numérique standard et chaînes de format numérique personnalisées.
• Pour connaître les valeurs de date et d’heure, consultez Chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.
• Pour connaître les valeurs d’énumération, consultez Chaînes de format d’énumération.
• Pour les valeurs TimeSpan, consultez les chaînes de format TimeSpan standard et les chaînes de format TimeSpan personnalisées.
• Pour consulter les valeurs Guid, veuillez vous référer à la section Remarques de la page de référence Guid.ToString(String).

Comment contrôler l’alignement des chaînes de résultat qui remplacent les éléments de format ?

La syntaxe générale d’un élément de format est la suivante :

{index[,width][: formatString]}

width est un entier signé qui définit la largeur du champ. Si cette valeur est négative, le texte du champ est aligné à gauche. S’il est positif, le texte est aligné à droite.

Comment contrôler le nombre de chiffres après le séparateur décimal ?

Toutes les chaînes de format numérique standard , à l’exception de « D » (utilisée uniquement avec des entiers), « G », « R » et « X » permettent un spécificateur de précision qui définit le nombre de chiffres décimaux dans la chaîne de résultat. L’exemple suivant utilise des chaînes de format numérique standard pour contrôler le nombre de chiffres décimaux dans la chaîne de résultat.

object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values)
{
    result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                           Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
    Console.WriteLine(result);
}
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

open System

let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
   String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n", Convert.ToDouble(value), Convert.ToDouble(value) / 10000.)
   |> printfn "%s"
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Module Example7
    Public Sub Main()
        Dim values() As Object = {1603, 1794.68235, 15436.14}
        Dim result As String
        For Each value In values
            result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
            Console.WriteLine(result)
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Si vous utilisez une chaîne de format numérique personnalisée, utilisez le spécificateur de format « 0 » pour contrôler le nombre de chiffres décimaux dans la chaîne de résultat, comme l’illustre l’exemple suivant.

decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
                              value);
Console.WriteLine(result);
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

Module Example8
    Public Sub Main()
        Dim value As Decimal = 16309.5436D
        Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
                                           value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

Comment contrôler le nombre de chiffres intégraux ?

Par défaut, les opérations de mise en forme affichent uniquement des chiffres intégral non nuls. Si vous mettez en forme des entiers, vous pouvez utiliser un spécificateur de précision avec les chaînes de format standard « D » et « X » pour contrôler le nombre de chiffres.

int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
//     001326   0000052E

open System

let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// The example displays the following output:
//     001326   0000052E

Module Example10
    Public Sub Main()
        Dim value As Integer = 1326
        Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       001326   0000052E

Vous pouvez remplir un nombre entier ou à virgule flottante avec des zéros de début pour produire une chaîne de résultat avec un nombre spécifié de chiffres intégraux à l’aide du spécificateur de format numérique personnalisé « 0 », comme l’illustre l’exemple suivant.

int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
                              value);
Console.WriteLine(result);
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

open System

let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

Module Example9
    Public Sub Main()
        Dim value As Integer = 16342
        Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
                                           value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

Combien d’éléments puis-je inclure dans la liste de formats ?

Il n’y a pas de limite pratique. Le deuxième paramètre de la Format(IFormatProvider, String, Object[]) méthode est marqué avec l’attribut ParamArrayAttribute , ce qui vous permet d’inclure une liste délimitée ou un tableau d’objets en tant que liste de format.

Comment inclure des accolades littérales (« { » et « } ») dans la chaîne de résultat ?

Par exemple, comment empêcher l’appel de méthode suivant de lever une FormatException exception ?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);

let result = 
    String.Format("The text has {0} '{' characters and {1} '}' characters.", nOpen, nClose)

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                 nOpen, nClose)

Une seule accolade d’ouverture ou de fermeture est toujours interprétée comme le début ou la fin d’un élément de format. Pour être interprété littéralement, elle doit être placée dans une séquence d’échappement. Vous placez une accolade dans une séquence d’échappement en ajoutant une autre accolade (« {{ » et « }} » au lieu de « { » et « } »), comme dans l’appel de méthode suivant :

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);

let result =
    String.Format("The text has {0} '{{' characters and {1} '}}' characters.", nOpen, nClose)

result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                 nOpen, nClose)

Toutefois, même les accolades placées dans une séquence d’échappement sont facilement mal interprétées. Nous vous recommandons d’inclure des accolades dans la liste de formats et d’utiliser des éléments de format pour les insérer dans la chaîne de caractères résultante, comme l’illustre l’exemple suivant.

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}");
Console.WriteLine(result);

let result =
    String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.", nOpen, "{", nClose, "}")

result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                 nOpen, "{", nClose, "}")

Pourquoi mon appel à la méthode String.Format génère-t-il une FormatException ?

La cause la plus courante de l’exception est que l’index d’un élément de format ne correspond pas à un objet dans la liste de formats. Cela indique généralement que vous avez mal numéroté les index des éléments de format ou que vous avez oublié d’inclure un objet dans la liste de formats. La tentative d’inclure un caractère d’accolade gauche ou droite sans échappement déclenche également une FormatException. Parfois, l’exception est le résultat d’une faute de frappe ; par exemple, une erreur classique consiste à mal typer « [ » (crochet gauche) au lieu de « { » (accolades gauche).

Si la méthode Format(System.IFormatProvider,System.String,System.Object[]) prend en charge les tableaux de paramètres, pourquoi mon code lève-t-il une exception lorsque j’utilise un tableau ?

Par exemple, le code suivant lève une FormatException exception :

Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
    int number = rnd.Next(1001);
    numbers[ctr] = number;
    total += number;
}
numbers[3] = total;
Console.WriteLine($"{numbers} + {1} + {2} = {3}");

open System

let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)

Module Example5a
    Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
            Dim number As Integer = rnd.Next(1001)
            numbers(ctr) = number
            total += number
        Next
        numbers(3) = total
        Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
    End Sub
End Module

Il s’agit d’un problème de résolution de surcharge du compilateur. Étant donné que le compilateur ne peut pas convertir un tableau d’entiers en tableau d’objets, il traite le tableau d’entiers comme un seul argument, de sorte qu’il appelle la Format(String, Object) méthode. L’exception est levée, car il existe quatre éléments de format, mais seulement un seul élément dans la liste de formats.

Étant donné que Visual Basic ou C# ne peut pas convertir un tableau d’entiers en tableau d’objets, vous devez effectuer la conversion vous-même avant d’appeler la Format(String, Object[]) méthode. L’exemple suivant fournit une implémentation.

Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
    int number = rnd.Next(1001);
    numbers[ctr] = number;
    total += number;
}
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine($"{values} + {1} + {2} = {3}");

open System

let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)

Imports System.Collections.Generic

Module Example6
    Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
            Dim number As Integer = rnd.Next(1001)
            numbers(ctr) = number
            total += number
        Next
        numbers(3) = total
        Dim values(numbers.Length - 1) As Object
        numbers.CopyTo(values, 0)
        Console.WriteLine("{0} + {1} + {2} = {3}", values)
    End Sub
End Module

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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

Format(IFormatProvider, String, Object, Object, Object)

Source:

String.Manipulation.cs

Remplace les éléments de format dans 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);

static member Format : IFormatProvider * string * obj * obj * obj -> string

Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Paramètres

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

format

String

Chaîne de format composite.

arg0

Object

Premier objet à mettre en forme.

arg1

Object

Deuxième objet à mettre en forme.

arg2

Object

Troisième objet à mettre en forme.

Retours

String

Copie dont format les éléments de format ont été remplacés par les représentations sous forme de chaînes de arg0, arg1et arg2.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir trois expressions en leurs représentations sous forme de chaîne et 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.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme culturelle 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je appeler ?.

Format(IFormatProvider, String, Object, Object)

Source:

String.Manipulation.cs

Remplace les éléments de format 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);

static member Format : IFormatProvider * string * obj * obj -> string

Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

Paramètres

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

format

String

Chaîne de format composite.

arg0

Object

Premier objet à mettre en forme.

arg1

Object

Deuxième objet à mettre en forme.

Retours

String

Copie des format éléments de format remplacés par les représentations sous forme de chaîne de arg0 et arg1.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

format n’est pas valide.

- ou -

L’index d’un élément de format n’est pas égal ou égal à 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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir deux expressions en représentations sous forme de chaîne et 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.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme culturelle 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je appeler ?.

Format(String, Object, Object)

Source:

String.Manipulation.cs

Remplace les éléments de format 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);

static member Format : string * obj * obj -> string

Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

Paramètres

format

String

Chaîne de format composite.

arg0

Object

Premier objet à mettre en forme.

arg1

Object

Deuxième objet à mettre en forme.

Retours

String

Copie des format éléments de format remplacés par les représentations sous forme de chaîne de arg0 et arg1.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

format n’est pas valide.

- ou -

L’index d’un élément de format n’est pas égal ou égal à 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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

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 incorporer ces représentations dans une chaîne.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je 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 (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.

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

• Types de mise en forme 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
• Chaînes de format numérique personnalisées
• Chaînes de format TimeSpan standard
• Chaînes de format TimeSpan personnalisées
• Chaînes de format d’énumération

Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments dans une CompositeFormat 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, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, scoped ReadOnlySpan<object?> args);

static member Format : IFormatProvider * System.Text.CompositeFormat * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, args As ReadOnlySpan(Of Object)) As String

Paramè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

String

Chaîne mise en forme.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.

Format(IFormatProvider, CompositeFormat, Object[])

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments dans une CompositeFormat 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[] -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, ParamArray args As Object()) As String

Paramè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

String

Chaîne mise en forme.

Exceptions

ArgumentNullException

format ou args est null.

FormatException

L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.

Format(String, Object, Object, Object)

Source:

String.Manipulation.cs

Remplace les éléments de format dans 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);

static member Format : string * obj * obj * obj -> string

Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Paramètres

format

String

Chaîne de format composite.

arg0

Object

Premier objet à mettre en forme.

arg1

Object

Deuxième objet à mettre en forme.

arg2

Object

Troisième objet à mettre en forme.

Retours

String

Copie dont format les éléments de format ont été remplacés par les représentations sous forme de chaînes de arg0, arg1et arg2.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

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 incorporer ces représentations dans une chaîne.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je 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 inclut six éléments de format, 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 façons différentes.

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

• Types de mise en forme dans .NET
• Mise en forme composite

Format(IFormatProvider, String, Object[])

Source:

String.Manipulation.cs

Remplace les éléments de format dans une chaîne par les représentations sous forme de chaîne d’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);

static member Format : IFormatProvider * string * obj[] -> string

Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

Paramètres

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

format

String

Chaîne de format composite.

args

Object[]

Tableau d’objets qui contient zéro ou plusieurs objets à mettre en forme.

Retours

String

Copie des format éléments de format dans lesquels les éléments de format ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.

Exceptions

ArgumentNullException

format ou args est null.

FormatException

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 args tableau.

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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir quatre expressions ou plus en représentations sous forme de chaîne et 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.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme culturelle 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je 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 Example2
   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
• Types de mise en forme 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
• Chaînes de format numérique personnalisées
• Chaînes de format TimeSpan standard
• Chaînes de format TimeSpan personnalisées
• Chaînes de format d’énumération

Format(IFormatProvider, String, Object)

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments 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);

static member Format : IFormatProvider * string * obj -> string

Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String

Paramètres

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

format

String

Chaîne de format composite.

arg0

Object

Objet à mettre en forme.

Retours

String

Copie de format l’élément de format ou des éléments qui ont été remplacés par la représentation sous forme de chaîne de arg0.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

format n’est pas valide.

- ou -

L’index d’un élément de format n’est pas égal à 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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

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 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 se convertit en sa représentation sous forme de chaîne en arg0 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.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme culturelle 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je appeler ?.

Format(String, ReadOnlySpan<Object>)

Source:

String.Manipulation.cs

Remplace l’élément de format dans une chaîne spécifiée par la représentation sous forme de chaîne d’un objet correspondant dans une étendue spécifiée.

public:
 static System::String ^ Format(System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(string format, scoped ReadOnlySpan<object?> args);

static member Format : string * ReadOnlySpan<obj> -> string

Public Shared Function Format (format As String, args As ReadOnlySpan(Of Object)) As String

Paramètres

format

String

Chaîne de format composite.

args

ReadOnlySpan<Object>

Étendue d’objet qui contient zéro ou plusieurs objets à mettre en forme.

Retours

String

Copie des format éléments de format dans lesquels les éléments de format ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.

Format(String, Object[])

Source:

String.Manipulation.cs

Remplace l’élément de format dans 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);

static member Format : string * obj[] -> string

Public Shared Function Format (format As String, ParamArray args As Object()) As String

Paramètres

format

String

Chaîne de format composite.

args

Object[]

Tableau d’objets qui contient zéro ou plusieurs objets à mettre en forme.

Retours

String

Copie des format éléments de format dans lesquels les éléments de format ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.

Exceptions

ArgumentNullException

format ou args est null.

FormatException

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 args tableau.

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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de quatre expressions ou plus en leurs représentations sous forme 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 transmettre les objets à la méthode en tant qu’arguments individuels ou en tant que Object tableau.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je 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 sous forme 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.

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 passer les objets à mettre en forme en tant que tableau plutôt qu’en tant que liste d’arguments.

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 FormatExample10
{
   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

• Types de mise en forme 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
• Chaînes de format numérique personnalisées
• Chaînes de format TimeSpan standard
• Chaînes de format TimeSpan personnalisées
• Chaînes de format d’énumération

Format(String, Object)

Source:

String.Manipulation.cs

Remplace un ou plusieurs éléments de format dans 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);

static member Format : string * obj -> string

Public Shared Function Format (format As String, arg0 As Object) As String

Paramètres

format

String

Chaîne de format composite.

arg0

Object

Objet à mettre en forme.

Retours

String

Copie dont format tous les éléments de format sont remplacés par la représentation sous forme de chaîne de arg0.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

L’élément de format dans lequel il format n’est pas valide.

- ou -

L’index d’un élément de format n’est pas égal à 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 langue les prend en charge. Une chaîne interpolée est une chaîne qui contient des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (référence C#) et chaînes interpolées (référence Visual Basic).

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 incorporer cette représentation dans une chaîne.

Toutefois, lors de l’appel de la String.Format méthode, il n’est pas nécessaire de se concentrer sur la surcharge particulière que vous souhaitez 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 des valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index de 0 et 1 doit avoir 2 arguments ; une avec les index 0 à 5 doit avoir 6 arguments. Le compilateur de langage résout ensuite votre appel de méthode à une surcharge particulière de la String.Format méthode.

Pour obtenir une documentation plus détaillée sur l’utilisation de la String.Format méthode, consultez Prise en main de la méthode String.Format et Quelle méthode dois-je appeler ?.

Exemple : Mise en forme d’un seul argument

L’exemple suivant utilise la Format(String, Object) méthode pour incorporer l’âge d’une personne au milieu d’une chaîne.

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

• Types de mise en forme 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
• Chaînes de format numérique personnalisées
• Chaînes de format TimeSpan standard
• Chaînes de format TimeSpan personnalisées
• Chaînes de format d’énumération

Format(IFormatProvider, String, ReadOnlySpan<Object>)

Source:

String.Manipulation.cs

Remplace les éléments de format dans une chaîne par les représentations sous forme de chaîne des objets correspondants dans une étendue spécifiée. Un paramètre fournit des informations de mise en forme propres à la culture.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, string format, scoped ReadOnlySpan<object?> args);

static member Format : IFormatProvider * string * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As String, args As ReadOnlySpan(Of Object)) As String

Paramètres

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

format

String

Chaîne de format composite.

args

ReadOnlySpan<Object>

Étendue d’objet qui contient zéro ou plusieurs objets à mettre en forme.

Retours

String

Copie des format éléments de format dans lesquels les éléments de format ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.

Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments dans une CompositeFormat 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 -> string

Public Shared Function Format(Of TArg0, TArg1, TArg2) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1, arg2 As TArg2) As String

Paramè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

String

Chaîne mise en forme.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.

Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments dans une CompositeFormat 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 -> string

Public Shared Function Format(Of TArg0, TArg1) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1) As String

Paramè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

String

Chaîne mise en forme.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.

Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)

Source:

String.Manipulation.cs

Remplace l’élément de format ou les éléments dans une CompositeFormat 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 -> string

Public Shared Function Format(Of TArg0) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0) As String

Paramè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

String

Chaîne mise en forme.

Exceptions

ArgumentNullException

format a la valeur null.

FormatException

L’index d’un élément de format est supérieur ou égal au nombre d’arguments fournis.