String.Format Méthode

Définition

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

Si vous découvrez la méthode String.Format, consultez la section Bien démarrer avec la méthode String.Format pour afficher une présentation rapide.

Consultez la section Notes afin d’obtenir une documentation générale sur la méthode String.Format.

Surcharges

Format(String, Object)

Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié.

Format(String, Object[])

Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié.

Format(IFormatProvider, String, Object)

Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant. Un paramètre fournit des informations de mise en forme propres à la culture.

Format(IFormatProvider, String, Object[])

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

Format(String, Object, Object)

Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés.

Format(IFormatProvider, String, Object, Object)

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

Format(String, Object, Object, Object)

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.

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

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture.

Exemples

De nombreux exemples qui appellent la Format méthode sont intercalés dans la section Notes de cet article.

Vous pouvez également télécharger un ensemble complet d' String.Format exemples, qui sont inclus dans un projet .net Core pour C#.

Voici quelques exemples inclus dans l’article :

Créer une chaîne de format

Insertion d’une chaîne
Élément de mise en forme
Mettre en forme les éléments qui ont le même index

Contrôler la sortie mise en forme

Contrôle de la mise en forme
Contrôle de l’espacement
Contrôler l’alignement
Contrôle du nombre de chiffres intégraux
Contrôle du nombre de chiffres après le séparateur décimal
Inclusion d’accolades littérales dans une chaîne de résultat

Rendre les chaînes de format dépendantes de la culture

Mise en forme dépendante de 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

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Dans cette section :

Prise en main de la méthode String. format
Quelle méthode appelle-t-elle ?
Méthode format en bref
Élément de mise en forme
Mode de mise en forme des arguments
Mettre en forme les éléments qui ont le même index
Mise en forme et culture
Opérations de mise en forme personnalisée
Chaîne. format Q & A

Prise en main de la méthode String. format

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

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
                           pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
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 contrôler la mise en forme de cette valeur :

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

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

Insérer une chaîne

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

Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
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.'

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

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

String^ s = String::Format("At {0}, the temperature is {1}°C.",
                           DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
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 que vous le souhaitez dans la liste d’objets, tant que l’index de chaque élément de mise en forme 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électionnera celui qui convient le mieux.

Mise en forme du contrôle

Vous pouvez suivre l’index d’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 dans la liste d’objets. Voici un exemple avec un objet unique et deux éléments de mise en forme :

String^ s = String::Format("It is now {0:d} at {0:t}",
                           DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
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'

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

Espacement des contrôles

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 compte plus de 12 caractères, la largeur du champ par défaut 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 d’autres chaînes d’année, ainsi qu’un champ de 15 caractères pour contenir la chaîne « population » et certaines données de population. Notez que les caractères sont alignés à droite dans le champ.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
   sb->AppendFormat("{0,6} {1,15:N0}\n",
                    years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
     int[] years = { 2013, 2014, 2015 };
     int[] population = { 1025632, 1105967, 1148203 };
     var sb = new System.Text.StringBuilder();
     sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
     for (int index = 0; index < years.Length; index++)
        sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

     Console.WriteLine(sb);

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

Alignement du contrôle

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

L’exemple suivant est semblable au précédent, à ceci près qu’il aligne à gauche les étiquettes et les données.

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

À Call
Mettre 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 Format surcharges restantes incluent un String paramètre suivi d’un ou plusieurs paramètres d’objet. C’est la raison pour laquelle vous n’avez pas besoin de déterminer la Format surcharge que vous souhaitez appeler. Le 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 a cinq arguments, le compilateur appelle la Format(String, Object[]) méthode.
Mettre en forme un ou plusieurs objets à l’aide des conventions d’une culture spécifique. Chaque Format surcharge qui commence par un provider paramètre est suivie par un String paramètre et un ou plusieurs paramètres d’objet. Pour cette raison, vous n’avez pas besoin de déterminer la Format surcharge spécifique que vous souhaitez appeler. Le 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 a cinq arguments, le compilateur appelle la Format(IFormatProvider, String, Object[]) méthode.
Effectue une opération de mise en forme personnalisée avec une ICustomFormatter implémentation ou une IFormattable implémentation. L’une des quatre surcharges avec un provider paramètre. Le compilateur sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments.

Méthode format en bref

Chaque surcharge de la Format méthode utilise la fonctionnalité de mise en forme composite pour inclure des espaces réservés index de base zéro, appelés éléments de mise en forme, dans une chaîne de format composite. Au moment de l’exécution, chaque élément de mise en forme 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 mise en forme est remplacé par String.Empty . Par exemple, l’appel suivant à la Format(String, Object, Object, Object) méthode comprend une chaîne de format avec trois éléments de mise en forme,, {0} {1} et {2} , ainsi qu’une liste d’arguments avec trois éléments.

using namespace System;

void main()
{
   DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0); 
   String^ city = "Chicago";
   int temp = -16;
   String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp);
   Console::WriteLine(output);
}
// The example displays the following output: 
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
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 mise en forme

Un élément de format a la syntaxe suivante :

{index[,alignment][:formatString]}

Les crochets désignent des éléments facultatifs. Les accolades ouvrantes et fermantes sont requises. (Pour inclure une accolade ouvrante ou fermante dans la chaîne de format, consultez la section accolades d’échappement dans l’article sur la mise en forme composite .)

Par exemple, un élément de mise en forme pour mettre en forme une valeur monétaire peut se présenter comme suit :

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

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

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

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

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

formatString
Optionnel. Chaîne qui spécifie le format de la chaîne de résultat de l’argument correspondant. Si vous omettez FormatString, la méthode sans paramètre de l’argument correspondant ToString 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 mise en forme doit implémenter l' IFormattable interface. Les types qui prennent en charge les chaînes de format sont les suivants :

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

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

using namespace System;

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

   // Display header
   String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                   "City", "Year", "Population", "Change (%)");
   Console::WriteLine(header);
   String^ output;      
   for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
      output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                              city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
                              (city->Item5 - city->Item3)/ (double)city->Item3);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities = 
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                   new DateTime(1950, 1, 1), 7891957),  
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                   new DateTime(1950, 1, 1), 3620962),  
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
Module Example
   Public Sub Main()
      ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),  
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),  
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }

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

Mode de mise en forme des arguments

Les éléments de mise en forme sont traités de manière séquentielle à partir du début de la chaîne. Chaque élément de mise en forme 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 :

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

Pour plus d’informations, consultez la section ordre de traitement dans l’article sur la mise en forme composite .

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

La Format méthode lève une FormatException exception si l’index d’un élément d’index est supérieur ou égal au nombre d’arguments dans la liste d’arguments. Toutefois, format peut inclure plus d’éléments de format qu’il n’y a d’arguments, à condition que plusieurs éléments de format aient le même index. Dans l’appel à la Format(String, Object) méthode dans l’exemple suivant, la liste d’arguments a un seul argument, mais la chaîne de format inclut deux éléments de mise en forme : l’un affiche la valeur décimale d’un nombre, tandis que 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
Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
      Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
      Console.WriteLine()
      For Each value As Short In values
         Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
         Console.WriteLine(formatString)
      Next        
   End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Format et culture

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

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

  • CultureInfo. Sa GetFormat méthode retourne un objet spécifique à la culture NumberFormatInfo pour mettre en forme des valeurs numériques et un objet spécifique à la culture DateTimeFormatInfo pour mettre en forme les valeurs de date et d’heure.

  • DateTimeFormatInfo, qui est utilisé pour la mise en forme spécifique à la culture des valeurs de date et d’heure. Sa GetFormat méthode retourne lui-même.

  • NumberFormatInfo, qui est utilisé pour la mise en forme spécifique à la culture des valeurs numériques. Sa GetFormat propriété se retourne lui-même.

Opérations de mise en forme personnalisée

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

Pour plus d’informations sur la façon de fournir des solutions de mise en forme personnalisées, consultez Comment : définir et utiliser des fournisseurs de format numérique 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 namespace System;

ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType) 
   {
      if (formatType == ICustomFormatter::typeid)        
         return this; 
      else 
         return nullptr; 
   }
   
   virtual String^ Format(String^ format, 
                   Object^ arg, 
                   IFormatProvider^ formatProvider) 
   {                       
      if (! this->Equals(formatProvider))
      {
         return nullptr;
      }
      else
      {
         if (String::IsNullOrEmpty(format)) 
            format = "G";
         
         String^ customerString = arg->ToString();
         if (customerString->Length < 8)
            customerString = customerString->PadLeft(8, '0');
         
         format = format->ToUpper();
         if (format == L"G") 
               return customerString->Substring(0, 1) + "-" +
                                     customerString->Substring(1, 5) + "-" +
                                     customerString->Substring(6);
         else if (format == L"S")                          
               return customerString->Substring(0, 1) + "/" +
                                     customerString->Substring(1, 5) + "/" +
                                     customerString->Substring(6);
         else if (format == L"P")
               return customerString->Substring(0, 1) + "." +
                                     customerString->Substring(1, 5) + "." +
                                     customerString->Substring(6);
         else
               throw gcnew FormatException( 
                         String::Format("The '{0}' format specifier is not supported.", format));
         }
    }   
};

void main()
{
   int acctNumber = 79203159;
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
   try {
      Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
   }
   catch (FormatException^ e) {
      Console::WriteLine(e->Message);
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
using System;

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

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

  • Elle affiche les paramètres passés à son ICustomFormatter.Format implémentation. Cela nous permet de voir les paramètres que la Format(IFormatProvider, String, Object[]) méthode passe à l’implémentation de mise en forme personnalisée pour chaque objet qu’elle essaie 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 sous la forme d’un chiffre romain.

using namespace System;
using namespace System::Globalization;

ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType)
   {
      if (formatType == ICustomFormatter::typeid)   
         return this;
      else
         return nullptr;
   }
   
   virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider) 
   {
      // Display information about method call.
      String^ formatString = format != nullptr ? format : "<null>";
      Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj != nullptr ? obj : "<null>", formatString);
                        
      if (obj == nullptr) return String::Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String^ returnString = String::Empty;

         // Get the hundreds digit(s)
         result = Math::DivRem(value, 100, remainder);
         if (result > 0)  
            returnString = gcnew String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math::DivRem(value, 50, remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math::DivRem(value, 10, remainder);
         if (result > 0)
            returnString += gcnew String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math::DivRem(value, 5, remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += gcnew String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString->IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString->IndexOf("L"); 
            if ((xPos >= 0) & (xPos == pos - 1))
               returnString = returnString->Replace("LXXXX", "XC");
            else
               returnString = returnString->Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString->IndexOf("IIII");
         if (pos >= 0)
            if (returnString->IndexOf("V") >= 0)
               returnString = returnString->Replace("VIIII", "IX");
            else
               returnString = returnString->Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj->GetType() == IFormattable::typeid)
         return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
      else
         return obj->ToString();
   }
};

void main()
{
   int n = 10;
   double value = 16.935;
   DateTime day = DateTime::Now;
   InterceptProvider^ provider = gcnew InterceptProvider();
   Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
   Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ", 
                                    (DayOfWeek) DateTime::Now.DayOfWeek));
   Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
   Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

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

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
Imports System.Globalization

Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
         Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

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

Chaîne. format Q & A

Pourquoi recommandez-vous l’interpolation de chaîne sur les appels à la String.Format méthode ?

L’interpolation de chaîne est :

  • Plus flexible. Elle peut être utilisée dans n’importe quelle chaîne sans nécessiter un appel à une méthode qui prend en charge la mise en forme composite. Sinon, vous devez appeler la Format méthode ou une autre méthode qui prend en charge la mise en forme composite, telle que Console.WriteLine ou StringBuilder.AppendFormat .

  • Plus lisibles. Étant donné que l’expression à insérer dans une chaîne apparaît dans l’expression interpolée plutôt que dans une liste d’arguments, les chaînes interpolées sont beaucoup plus faciles à coder et à lire. En raison de leur meilleure lisibilité, les chaînes interpolées peuvent remplacer non seulement les appels aux méthodes de format composite, mais elles peuvent également être utilisées dans les opérations de concaténation de chaînes pour produire un code plus concis et plus clair.

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

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

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

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

En revanche, l’utilisation de chaînes interpolées dans l’exemple suivant génère un code plus clair et plus concis que l’instruction de concaténation de chaînes 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.

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

Où puis-je trouver la liste des chaînes de format prédéfinies qui peuvent être utilisées avec les éléments de format ?

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

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

{index[,alignment][: formatString]}

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

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

Toutes les chaînes de format numériques standard , à l’exception de « D » (qui est utilisé uniquement avec des entiers), « G », « R » et « X », autorisent un spécificateur de précision qui définit le nombre de chiffres décimaux dans la chaîne de résultat. L’exemple suivant utilise des chaînes de format numériques 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 %
Module Example
   Public Sub Main()
      Dim values() As Object = { 1603, 1794.68235, 15436.14 }
      Dim result As String
      For Each value In values
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
         Console.WriteLine(result) 
         Console.WriteLine()
      Next                             
   End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

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

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

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

Par défaut, les opérations de mise en forme affichent uniquement des chiffres entiers 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
Module Example
   Public Sub Main()
      Dim value As Integer = 1326
      Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       001326   0000052E

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

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

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

Il n’existe aucune limite pratique. Le deuxième paramètre de la Format(IFormatProvider, String, Object[]) méthode est marqué avec l' ParamArrayAttribute attribut, ce qui vous permet d’inclure une liste délimitée ou un tableau d’objets comme liste de formats.

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

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

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

Une seule accolade ouvrante ou fermante est toujours interprétée comme le début ou la fin d’un élément de format. Pour être interprété littéralement, il doit être placé dans une séquence d’échappement. Vous échappez une accolade en ajoutant une autre accolade (« {{ » et « }} » à la place 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);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose)

Toutefois, même les accolades échappées sont facilement mal interprétées. Nous vous recommandons d’inclure des accolades dans la liste format et d’utiliser des éléments de mise en forme pour les insérer dans la chaîne de résultat, comme le montre l’exemple suivant.

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

Pourquoi mon appel à la méthode String. format lève-t-il un FormatException ?

La cause la plus courante de l’exception est que l’index d’un élément de mise en forme ne correspond pas à un objet dans la liste de formats. En général, cela indique que vous n’avez pas numéroté les index des éléments de mise en forme ou que vous avez oublié d’inclure un objet dans la liste format. Si vous tentez d’inclure un caractère sans séquence d’échappement à gauche ou à droite, une exception est également levée FormatException . Parfois, l’exception est le résultat d’une faute de frappe ; par exemple, une erreur classique consiste à inverser le type « [ » (crochet gauche) au lieu de « { » (accolade ouvrante).

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

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

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

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

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

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

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

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

Format(String, Object)

Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
public static string Format (string format, object? arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String

Paramètres

arg0
Object

Objet à mettre en forme.

Retours

String

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

Exceptions

format a la valeur null.

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

  • ou -

L’index d’un élément de format n’est pas zéro.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur d’une expression en sa représentation sous forme de chaîne et pour incorporer cette représentation dans une chaîne.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

Exemple : mise en forme d’un 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.

using namespace System;

void main()
{
   DateTime birthdate = DateTime(1993, 7, 28);
   array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16), 
                                                    DateTime(1994, 7, 28), 
                                                    DateTime(2000, 10, 16), 
                                                    DateTime(2003, 7, 27), 
                                                    DateTime(2007, 5, 27) };

   for each (DateTime dateValue in dates)
   {
      TimeSpan interval = dateValue - birthdate;
      // Get the approximate number of years, without accounting for leap years.
      int years = ((int)interval.TotalDays) / 365;
      // See if adding the number of years exceeds dateValue.
      String^ output;
      if (birthdate.AddYears(years) <= dateValue) {
         output = String::Format("You are now {0} years old.", years);
         Console::WriteLine(output);
      }   
      else {
         output = String::Format("You are now {0} years old.", years - 1);
         Console::WriteLine(output);
      }      
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16), 
                     new DateTime(1994, 7, 28), 
                     new DateTime(2000, 10, 16), 
                     new DateTime(2003, 7, 27), 
                     new DateTime(2007, 5, 27) };

foreach (DateTime dateValue in dates)
{
   TimeSpan interval = dateValue - birthdate;
   // Get the approximate number of years, without accounting for leap years.
   int years = ((int) interval.TotalDays) / 365;
   // See if adding the number of years exceeds dateValue.
   string output;
   if (birthdate.AddYears(years) <= dateValue) {
      output = String.Format("You are now {0} years old.", years);
      Console.WriteLine(output);
   }   
   else {
      output = String.Format("You are now {0} years old.", years - 1);
      Console.WriteLine(output);
   }      
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
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

S’applique à

Format(String, Object[])

Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
public static string Format (string format, params object?[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String

Paramètres

args
Object[]

Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.

Retours

String

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

Exceptions

format ou args est null.

format n'est pas valide.

  • ou -

L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de quatre expressions ou plus en 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' System.ParamArrayAttribute attribut, vous pouvez passer les objets à la méthode en tant qu’arguments individuels ou en tant que Object tableau.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

Exemple : mettre en forme plus de trois arguments

Cet exemple crée une chaîne qui contient des données sur les températures haute et basse à une date particulière. la chaîne de format composite comporte cinq éléments de mise en forme dans l’exemple C# et six dans l’exemple de Visual Basic. Deux des éléments de mise en forme définissent la largeur de la représentation sous forme de chaîne de leur valeur correspondante, et le premier élément de mise en forme comprend également une chaîne de format de date et d’heure standard.

using namespace System;

void main()
{
   DateTime date1 = DateTime(2009, 7, 1);
   TimeSpan hiTime = TimeSpan(14, 17, 32);
   Decimal hiTemp = (Decimal) 62.1; 
   TimeSpan loTime = TimeSpan(3, 16, 10);
   Decimal loTemp = (Decimal)54.8; 

   String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    date1, hiTime, hiTemp, loTime, loTemp);
   Console::WriteLine(result1);
   Console::WriteLine();
           
   String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
   Console::WriteLine(result2);
}
// The example displays the following output:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m; 
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m; 

string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
     
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
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 namespace System;

ref class CityInfo
{
public:
   CityInfo(String^ name, int population, Decimal area, int year)
   {
      this->Name = name;
      this->Population = population;
      this->Area = area;
      this->Year = year;
   }
   
   String^ Name; 
   int Population;
   Decimal Area;
   int Year;
};

ref class Example
{
public:
   static void ShowPopulationData(CityInfo^ city)
   {
      array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
      String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console::WriteLine(result); 
   }
};

void main()
{
   CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
   Example::ShowPopulationData(nyc2010);
   CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);      
   Example::ShowPopulationData(sea2010); 
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;

public class CityInfo
{
   public CityInfo(String name, int population, Decimal area, int year)
   {
      this.Name = name;
      this.Population = population;
      this.Area = area;
      this.Year = year;
   }
   
   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class Example
{
   public static void Main()
   {
      CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
      ShowPopulationData(nyc2010);
      CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);      
      ShowPopulationData(sea2010); 
   }

   private static void ShowPopulationData(CityInfo city)
   {
      object[] args = { city.Name, city.Year, city.Population, city.Area };
      String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console.WriteLine(result); 
   }
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
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

S’applique à

Format(IFormatProvider, String, Object)

Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant. Un paramètre fournit des informations de mise en forme propres à la culture.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
public static string Format (IFormatProvider? provider, string format, object? arg0);
static member Format : IFormatProvider * string * obj -> 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.

arg0
Object

Objet à mettre en forme.

Retours

String

Copie de format dans laquelle le ou les éléments de mise en forme sont remplacés par la représentation sous forme de chaîne de arg0.

Exceptions

format a la valeur null.

format n'est pas valide.

  • ou -

L’index d’un élément de format n’est pas zéro.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur d’une expression en sa représentation sous forme de chaîne et pour incorporer cette représentation dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme dépendante de la culture ou un formateur personnalisé. La méthode convertit en arg0 sa représentation sous forme de chaîne en appelant sa méthode ToString (IFormatProvider) ou, si l’élément de format correspondant à l’objet comprend une chaîne de format, en appelant sa méthode ToString (String, IFormatProvider) . Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

S’applique à

Format(IFormatProvider, String, Object[])

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

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
public static string Format (IFormatProvider? provider, string format, params object?[] args);
static member Format : IFormatProvider * string * obj[] -> 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.

args
Object[]

Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.

Retours

String

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

Exceptions

format ou args est null.

format n'est pas valide.

  • ou -

L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir quatre expressions ou plus en leurs représentations sous forme de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme dépendante de 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 à l’objet comprend une chaîne de format, en appelant sa méthode ToString (String, IFormatProvider) . Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

Exemple : mise en forme dépendante de 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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
      
      Dim dateToDisplay As Date = #9/1/2009 6:32PM#
      Dim value As Double = 9164.32

      Console.WriteLine("Culture     Date                                Value")
      Console.WriteLine()      
      For Each cultureName As String In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
                                              culture.Name, dateToDisplay, value)
         Console.WriteLine(output)
      Next    
   End Sub
End Module
' The example displays the following output:
'       Culture     Date                                Value
'       
'       en-US       Tuesday, September 01, 2009         9,164.32
'       fr-FR       mardi 1 septembre 2009              9 164,32
'       de-DE       Dienstag, 1. September 2009         9.164,32
'       es-ES       martes, 01 de septiembre de 2009    9.164,32

Voir aussi

S’applique à

Format(String, Object, Object)

Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
public static string Format (string format, object? arg0, object? arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

Paramètres

arg0
Object

Premier objet à mettre en forme.

arg1
Object

Deuxième objet à mettre en forme.

Retours

String

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.

Exceptions

format a la valeur null.

format n'est pas valide.

  • ou -

L’index d’un élément de format n’est pas zéro ou un.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de deux expressions en représentations de chaîne et pour incorporer ces représentations dans une chaîne.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

Exemple : mettre en forme deux arguments

Cet exemple utilise la Format(String, Object, Object) méthode pour afficher les données de temps et de température stockées dans un Dictionary<TKey,TValue> objet générique. Notez que la chaîne de format comporte trois éléments de mise en forme, bien qu’il n’y ait que deux objets à mettre en forme. Cela est dû au fait que le premier objet de la liste (une valeur de date et d’heure) est utilisé par deux éléments de mise en forme : le premier élément de mise en forme affiche l’heure, tandis que le deuxième affiche la date.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
   Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>(); 
   temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
   temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
   Console::WriteLine("Temperature Information:\n");
   String^ output;   
   for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
   {
      output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F", 
                              item->Key, item->Value);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5�F
//       Temperature at 10:00 AM on 12/1/2010:  36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

Console.WriteLine("Temperature Information:\n");
string output;   
foreach (var item in temperatureInfo)
{
   output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                          item.Key, item.Value);
   Console.WriteLine(output);
}
// The example displays output like the following:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5°F
//       Temperature at 10:00 AM on 12/1/2010:  36.8°F
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

S’applique à

Format(IFormatProvider, String, Object, Object)

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

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1);
static member Format : IFormatProvider * string * obj * obj -> 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.

arg0
Object

Premier objet à mettre en forme.

arg1
Object

Deuxième objet à mettre en forme.

Retours

String

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.

Exceptions

format a la valeur null.

format n'est pas valide.

  • ou -

L’index d’un élément de format n’est pas zéro ou un.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir deux expressions en représentations de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme dépendante de 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 à l’objet comprend une chaîne de format, en appelant sa méthode ToString (String, IFormatProvider) . Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

S’applique à

Format(String, Object, Object, Object)

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
public static string Format (string format, object? arg0, object? arg1, object? arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Paramètres

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 de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.

Exceptions

format a la valeur null.

format n'est pas valide.

  • ou -

L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir la valeur de trois expressions en représentations de chaîne et pour incorporer ces représentations dans une chaîne.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

Exemple : mettre en forme trois arguments

Cet exemple utilise la Format(String, Object, Object, Object) méthode pour créer une chaîne qui illustre le résultat d’une opération booléenne And avec deux valeurs entières. Notez que la chaîne de format inclut six éléments de mise en forme, mais que la méthode a seulement trois éléments dans sa liste de paramètres, car chaque élément est mis en forme de deux manières différentes.

using namespace System;

void main()
{
   String^ formatString = "    {0,10} ({0,8:X8})\n" + 
                           "And {1,10} ({1,8:X8})\n" + 
                           "  = {2,10} ({2,8:X8})";
   int value1 = 16932;
   int value2 = 15421;
   String^ result = String::Format(formatString, 
                                   value1, value2, value1 & value2);
   Console::WriteLine(result);
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
string formatString = "    {0,10} ({0,8:X8})\n" + 
                      "And {1,10} ({1,8:X8})\n" + 
                      "  = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString, 
                              value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
Public Module Example
   Public Sub Main()
      Dim formatString As String = "    {0,10} ({0,8:X8})" + vbCrLf +  _
                                   "And {1,10} ({1,8:X8})" + vbCrLf + _
                                   "  = {2,10} ({2,8:X8})"
      Dim value1 As Integer = 16932
      Dim value2 As Integer = 15421
      Dim result As String = String.Format(formatString, _
                                           value1, value2, value1 And value2)
      Console.WriteLine(result)                          
   End Sub
End Module
' The example displays the following output:
'                16932 (00004224)
'       And      15421 (00003C3D)
'         =         36 (00000024)

Voir aussi

S’applique à

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

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. Un paramètre fournit des informations de mise en forme propres à la culture.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> 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.

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 de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.

Exceptions

format a la valeur null.

format n'est pas valide.

  • ou -

L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.

Remarques

Important

Au lieu d’appeler la méthode String.Format ou d’utiliser des chaînes de format composite, vous pouvez utiliser des chaînes interpolées si votre langage les prend en charge. Une chaîne interpolée est une chaîne contenant des expressions interpolées. Chaque expression interpolée est résolue avec la valeur de l’expression et incluse dans la chaîne du résultat quand la chaîne est affectée. Pour plus d’informations, consultez Interpolation de chaîne (Informations de référence sur C#) et Chaînes interpolées (Informations de référence sur Visual Basic).

Cette méthode utilise la fonctionnalité de mise en forme composite pour convertir trois expressions en représentations de chaîne et pour incorporer ces représentations dans une chaîne. Lors de l’exécution de la conversion, la méthode utilise une mise en forme dépendante de 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 à l’objet comprend une chaîne de format, en appelant sa méthode ToString (String, IFormatProvider) . Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.

Cependant, lors de l’appel de la méthode String.Format, il n’est pas nécessaire de prêter attention à la surcharge spécifique que vous voulez appeler. Au lieu de cela, vous pouvez appeler la méthode avec un objet qui fournit une mise en forme dépendante de la culture ou personnalisée, et une chaîne de format composite qui inclut un ou plusieurs éléments de format. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0. En plus de la chaîne initiale, votre appel de méthode doit avoir autant d’arguments supplémentaires qu’il a de valeurs d’index. Par exemple, une chaîne dont les éléments de format ont des index 0 et 1 doit avoir 2 arguments ; une chaîne avec des index de 0 à 5 doit avoir 6 arguments. Le compilateur de votre langage résout alors votre appel de méthode vers une surcharge spécifique de la méthode String.Format.

Pour une documentation plus détaillée sur l’utilisation de la méthode String.Format, consultez Bien démarrer avec la méthode String.Format et Quelle méthode appeler ?.

S’applique à