String.Format String.Format String.Format String.Format Method

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.Converts the value of objects to strings based on the formats specified and inserts them into another string.

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.If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview.

Consultez la section Notes afin d’obtenir une documentation générale sur la méthode String.Format.See the Remarks section for general documentation for the String.Format method.

Surcharges

Format(String, Object) Format(String, Object) Format(String, Object) 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é.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) 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é.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) 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.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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é.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) 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.Replaces the format items in a string with the string representation of two specified objects.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) 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.Replaces the format items in a string with the string representation of two specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) 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.Replaces the format items in a string with the string representation of three specified objects.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) 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.Replaces the format items in a string with the string representation of three specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.An parameter supplies culture-specific formatting information.

Exemples

De nombreux exemples qui appellent Format la méthode sont intercalés dans la section Notes de cet article.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter s’il apparaît pour exécuter un exemple dans une fenêtre interactive.When present, select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Vous pouvez également télécharger un ensemble complet d' String.Format exemples, qui sont inclus dans un projet .net Core 2,0 C# pour et un projet .net Core 2,0 pour Visual Basic, à partir du dépôt github dotnet/Samples.You can also download a complete set of String.Format examples, which are included a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Voici quelques exemples inclus dans l’article :The following are some of the examples included in the article:

Créer une chaîne de formatCreate a format string

Insertion d’une chaîneInserting a string
Élément de mise en formeThe format item
Mettre en forme les éléments qui ont le même indexFormat items that have the same index

Contrôler la sortie mise en formeControl formatted output

Contrôle de la mise en formeControlling formatting
Contrôle de l’espacementControlling spacing
Contrôler l’alignementControlling alignment
Contrôle du nombre de chiffres intégrauxControlling the number of integral digits
Contrôle du nombre de chiffres après le séparateur décimalControlling the number of digits after the decimal separator
Inclusion d’accolades littérales dans une chaîne de résultatIncluding literal braces in a result string

Rendre les chaînes de format dépendantes de la cultureMake format strings culture-sensitive

Mise en forme dépendante de la cultureCulture-sensitive formatting

Personnaliser l’opération de mise en formeCustomize the formatting operation

Opération de mise en forme personnaliséeA custom formatting operation
Un fournisseur d’interception et un formateur de chiffres romainsAn intercept provider and Roman numeral formatter

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Dans cette section :In this section:

Prise en main de la méthode String. format Get started with the String.Format method
Quelle méthode appelle-t-elle ? Which method do I call?
Méthode format en bref The Format method in brief
Élément de mise en forme The Format item
Mode de mise en forme des arguments How arguments are formatted
Mettre en forme les éléments qui ont le même index Format items that have the same index
Mise en forme et culture Formatting and culture
Opérations de mise en forme personnalisée Custom formatting operations
Chaîne. format Q & AString.Format Q & A

Prise en main de la méthode String. formatGet started with the String.Format method

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.Use String.Format if you need to insert the value of an object, variable, or expression into another string. 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 :For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:

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 :And you can control that value's formatting:

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.Besides formatting, you can also control alignment and spacing.

Insertion d’une chaîneInserting a string

String.Formatcommence 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.String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. Par exemple :For example:

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.The {0} in the format string is a format item. 0est l’index de l’objet dont la valeur de chaîne sera insérée à cette position.0 is the index of the object whose string value will be inserted at that 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.(Indexes start at 0.) If the object to be inserted is not a string, its ToString method is called to convert it to one before inserting it in the result string.

Voici un autre exemple qui utilise deux éléments de mise en forme et deux objets dans la liste d’objets :Here's another example that uses two format items and two objects in the object list:

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.You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. Vous n’avez pas non plus à vous soucier de la surcharge que vous appelez. le compilateur sélectionnera celui qui convient le mieux.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

Contrôle de la mise en formeControlling formatting

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.You can follow the index in a format item with a format string to control how an object is formatted. Par exemple, {0:d} applique la chaîne de format « d » au premier objet dans la liste d’objets.For example, {0:d} applies the "d" format string to the first object in the object list. Voici un exemple avec un objet unique et deux éléments de mise en forme :Here is an example with a single object and two format items:

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 ( standard et chaînes de format personnalisées ), tous les types énumération types énumérationet les GUID.A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. Vous pouvez également ajouter la prise en charge des chaînes de format à vos propres types.You can also add support for format strings to your own types.

Contrôle de l’espacementControlling spacing

Vous pouvez définir la largeur de la chaîne insérée dans la chaîne de résultat à l’aide d’une {0,12}syntaxe telle que, qui insère une chaîne de 12 caractères.You can define the width of the string that is inserted into the result string by using syntax such as {0,12}, which inserts a 12-character string. 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.In this case, the string representation of the first object is right-aligned in the 12-character field. (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.)(If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)

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.The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. Notez que les caractères sont alignés à droite dans le champ.Note that the characters are right-aligned in the field.

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

Contrôler l’alignementControlling alignment

Par défaut, les chaînes sont alignées à droite dans leur champ si vous spécifiez une largeur de champ.By default, strings are right-aligned within their field if you specify a field width. Pour aligner des chaînes à gauche dans un champ, vous faites précéder la largeur du champ d’un signe {0,-12} négatif, par exemple pour définir un champ aligné à gauche à 12 caractères.To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12} to define a 12-character left-aligned field.

L’exemple suivant est semblable au précédent, à ceci près qu’il aligne à gauche les étiquettes et les données.The following example is similar to the previous one, except that it left-aligns both labels and data.

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.Formatutilise la fonctionnalité de mise en forme composite.String.Format makes use of the composite formatting feature. Pour plus d’informations, consultez Mise en forme composite.For more information, see Composite Formatting.

Quelle méthode appelle-t-elle ?Which method do I call?

ÀTo CallCall
Mettre en forme un ou plusieurs objets à l’aide des conventions de la culture actuelle.Format one or more objects by using the conventions of the current culture. À l’exception des surcharges qui incluent provider un paramètre, les Format surcharges restantes incluent un String paramètre suivi d’un ou plusieurs paramètres d’objet.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. C’est la raison pour laquelle vous n’avez pas Format besoin de déterminer la surcharge que vous souhaitez appeler.Because of this, you don't have to determine which Format overload you intend to call. Le compilateur de langage sélectionne la surcharge appropriée parmi les surcharges qui n’ont pas provider de paramètre, en fonction de votre liste d’arguments.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Par exemple, si votre liste d’arguments a cinq arguments, le compilateur appelle Format(String, Object[]) la méthode.For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Mettre en forme un ou plusieurs objets à l’aide des conventions d’une culture spécifique.Format one or more objects by using the conventions of a specific culture. 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.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. Pour cette raison, vous n’avez pas besoin de déterminer Format la surcharge spécifique que vous souhaitez appeler.Because of this, you don't have to determine which specific Format overload you intend to call. 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.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Par exemple, si votre liste d’arguments a cinq arguments, le compilateur appelle Format(IFormatProvider, String, Object[]) la méthode.For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Effectue une opération de mise en forme personnalisée avec ICustomFormatter une implémentation ou IFormattable une implémentation.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. L’une des quatre surcharges avec un provider paramètre.Any of the four overloads with a provider parameter. Le compilateur sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Méthode format en brefThe Format method in brief

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émentsde mise en forme, dans une chaîne de format composite.Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. 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.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. Si la valeur de l’argument est null, l’élément de mise en forme String.Emptyest remplacé par.If the value of the argument is null, the format item is replaced with 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 {0}mise {1}en forme {2},, et, ainsi qu’une liste d’arguments avec trois éléments.For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.

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 formeThe format item

Un élément de format a la syntaxe suivante :A format item has this syntax:

{index[,alignment][:formatString]}  

Les crochets désignent des éléments facultatifs.Brackets denote optional elements. Les accolades ouvrantes et fermantes sont requises.The opening and closing braces are required. (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 .)(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Par exemple, un élément de mise en forme pour mettre en forme une valeur monétaire peut se présenter comme suit :For example, a format item to format a currency value might appear like this:

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 :A format item has the following elements:

indexindex
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.The zero-based index of the argument whose string representation is to be included at this position in the string. Si cet argument a nullla valeur, une chaîne vide est incluse à cette position dans la chaîne.If this argument is null, an empty string will be included at this position in the string.

alignmentalignment
Optionnel.Optional. Entier signé qui indique la longueur totale du champ dans lequel l’argument est inséré et s’il est aligné à droite (entier positif) ou aligné à gauche (entier négatif).A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). 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.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

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.If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.

formatStringformatString
Optionnel.Optional. Chaîne qui spécifie le format de la chaîne de résultat de l’argument correspondant.A string that specifies the format of the corresponding argument's result string. Si vous omettez FormatString, la ToString méthode sans paramètre de l’argument correspondant est appelée pour produire sa représentation sous forme de chaîne.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. Si vous spécifiez FormatString, l’argument référencé par l’élément de mise en forme IFormattable doit implémenter l’interface.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. Les types qui prennent en charge les chaînes de format sont les suivants :Types that support format strings include:

Toutefois, Notez que tout type personnalisé peut implémenter IFormattable ou étendre l’implémentation d' IFormattable un type existant.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

L’exemple suivant utilise les alignment arguments formatString et pour produire la sortie mise en forme.The following example uses the alignment and formatString arguments to produce formatted output.

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 argumentsHow arguments are formatted

Les éléments de mise en forme sont traités de manière séquentielle à partir du début de la chaîne.Format items are processed sequentially from the beginning of the string. Chaque élément de mise en forme a un index qui correspond à un objet dans la liste d’arguments de la méthode.Each format item has an index that corresponds to an object in the method's argument list. La Format méthode récupère l’argument et dérive sa représentation sous forme de chaîne comme suit :The Format method retrieves the argument and derives its string representation as follows:

Pour obtenir un exemple qui intercepte les appels ICustomFormatter.Format à la méthode et vous permet de voir les Format informations que la 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 formateurde chiffres romains.For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.

Pour plus d’informations, consultez la section ordre de traitement dans l’article sur la mise en forme composite .For more information, see the Processing Order section in the Composite Formatting article.

Mettre en forme les éléments qui ont le même indexFormat items that have the same 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.The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. 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.However, format can include more format items than there are arguments, as long as multiple format items have the same 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.In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.

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

Mise en forme et cultureFormatting and 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 CultureInfo.CurrentCulture actuelle, qui est retournée par la propriété.Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. Vous pouvez contrôler ce comportement en appelant l’une des surcharges de Format qui incluent un provider paramètre.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. 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.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

L' IFormatProvider interface a un seul membre, GetFormat, qui est chargé de retourner l’objet qui fournit les informations de mise en forme.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .Net propose trois IFormatProvider implémentations qui fournissent une mise en forme spécifique à la culture :.NET has three IFormatProvider implementations that provide culture-specific formatting:

Opérations de mise en forme personnaliséeCustom formatting operations

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.You can also call the any of the overloads of the Format method that have a provider parameter of type IFormatProvider to perform custom formatting operations. 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.For example, you could format an integer as an identification number or as a telephone number. Pour effectuer une mise en forme personnalisée provider , votre argument doit implémenter ICustomFormatter à la fois les IFormatProvider interfaces et.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. provider Format ICustomFormatter IFormatProvider.GetFormat Quand une Format ICustomFormatter implémentation de la méthode est passée comme argument, la méthode appelle son implémentation et demande un objet de type.When the Format method is passed an ICustomFormatter implementation as the provider argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. Il appelle ensuite la méthode ICustomFormatter de l' Format objet retourné pour mettre en forme chaque élément de mise en forme dans la chaîne composite qui lui est transmise.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

Pour plus d’informations sur la façon de fournir des solutions de mise en forme personnalisées, consultez Procédure : Définir et utiliser des fournisseurs de format numérique personnalisés et. ICustomFormatterFor more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. Pour obtenir un exemple qui convertit des entiers en nombres personnalisés mis en forme, consultez exemple : Opérationde mise en forme personnalisée.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Pour obtenir un exemple qui convertit des octets non signés en chiffres romains , consultez exemple : Un fournisseur d’interception et un formateurde chiffres romains.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Exemple : Opération de mise en forme personnaliséeExample: A custom formatting operation

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.This example defines a format provider that formats an integer value as a customer account number in the form 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 romainsExample: An intercept provider and Roman numeral formatter

Cet exemple définit un fournisseur de format personnalisé qui implémente ICustomFormatter les IFormatProvider interfaces et pour effectuer deux opérations :This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Elle affiche les paramètres passés à son ICustomFormatter.Format implémentation.It displays the parameters passed to its ICustomFormatter.Format implementation. Cela nous permet de voir les paramètres que Format(IFormatProvider, String, Object[]) la méthode passe à l’implémentation de mise en forme personnalisée pour chaque objet qu’elle essaie de mettre en forme.This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. Cela peut être utile lorsque vous déboguez votre application.This can be useful when you're debugging your 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.If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.

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 & AString.Format Q & A

Pourquoi recommandez-vous l’interpolation de chaîne sur String.Format les appels à la méthode ?Why do you recommend string interpolation over calls to the String.Format method?

L’interpolation de chaîne est :String interpolation is:

  • Plus flexible.More 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.It can be used in any string without requiring a call to a method that supports composite formatting. Sinon, vous devez appeler la méthode Format ou une autre méthode qui prend en charge la mise en forme Console.WriteLine composite, telle que ou StringBuilder.AppendFormat.Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.

  • Plus lisibles.More readable. É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.Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. 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.Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.

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.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. L’utilisation de plusieurs opérations de concaténation de chaînes dans l’exemple suivant produit du code détaillé et difficile à lire.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

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 Format à la méthode dans l’exemple précédent.In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.

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 ?Where can I find a list of the predefined format strings that can be used with format items?

Comment faire contrôler l’alignement des chaînes de résultat qui remplacent les éléments de mise en forme ?How do I control the alignment of the result strings that replace format items?

La syntaxe générale d’un élément de format est la suivante :The general syntax of a format item is:

{index[,alignment][: formatString]}  

alignment est un entier signé qui définit la largeur du champ.where alignment is a signed integer that defines the field width. Si cette valeur est négative, le texte dans le champ est aligné à gauche.If this value is negative, text in the field is left-aligned. S’il est positif, le texte est aligné à droite.If it is positive, text is right-aligned.

Comment faire contrôler le nombre de chiffres après le séparateur décimal ?How do I control the number of digits after the decimal separator?

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.All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. 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.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

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.If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.

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 ?How do I control the number of integral digits?

Par défaut, les opérations de mise en forme affichent uniquement des chiffres entiers non nuls.By default, formatting operations only display non-zero integral digits. 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.If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.

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.You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.

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 ?How many items can I include in the format list?

Il n’existe aucune limite pratique.There is no practical limit. 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.The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.

Comment faire inclure des accolades littérales (« { » et « } ») dans la chaîne de résultat ?How do I include literal braces ("{" and "}") in the result string?

Par exemple, comment empêcher l’appel de méthode suivant de lever une FormatException exception ?For example, how do you prevent the following method call from throwing a 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.A single opening or closing brace is always interpreted as the beginning or end of a format item. Pour être interprété littéralement, il doit être placé dans une séquence d’échappement.To be interpreted literally, it must be escaped. Vous échappez une accolade en ajoutant une autre accolade (« {{ » et « }} » à la place de « { » et « } »), comme dans l’appel de méthode suivant :You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:

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.However, even escaped braces are easily misinterpreted. 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.We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.

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 ?Why does my call to the String.Format method throw a 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.The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. 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.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. Si vous tentez d’inclure un caractère sans séquence d’échappement à gauche ou à droite FormatException, une exception est également levée.Attempting to include an unescaped left or right brace character also throws a 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).Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).

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 ?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?

Par exemple, le code suivant lève une FormatException exception :For example, the following code throws a 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.This is a problem of compiler overload resolution. É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 Format(String, Object) unique, donc il appelle la méthode.Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. 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.The exception is thrown because there are four format items but only a single item in the format list.

Étant donné que ni C# Visual Basic ni ne pouvez convertir un tableau d’entiers en tableau d’objets, vous devez effectuer la conversion Format(String, Object[]) vous-même avant d’appeler la méthode.Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. L’exemple suivant fournit une implémentation.The following example provides one implementation.

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) Format(String, Object) Format(String, Object) 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é.Replaces one or more format items in a string with the string representation of a specified object.

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

Paramètres

arg0
Object Object Object Object

Objet à mettre en forme.The object to format.

Retours

Copie de format dans laquelle tous les éléments de mise en forme sont remplacés par la représentation sous forme de chaîne de arg0.A copy of format in which any format items are replaced by the string representation of arg0.

Exceptions

L’élément de format dans format n’est pas valide.The format item in format is invalid.

ou-or- L’index d’un élément de format n’est pas zéro.The index of a format item is not zero.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Exemple : Mise en forme d’un seul argumentExample: Formatting a single argument

L’exemple suivant utilise la Format(String, Object) méthode pour incorporer l’âge d’une personne au milieu d’une chaîne.The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.

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

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) 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é.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

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

Paramètres

args
Object[]

Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.An object array that contains zero or more objects to format.

Retours

Copie de format dans laquelle les éléments de mise en forme ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Exceptions

format ou args a la valeur null.format or args is null.

format n'est pas valide.format is invalid.

ou-or- L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. Étant donné args que le paramètre est marqué System.ParamArrayAttribute avec l’attribut, vous pouvez passer les objets à la méthode en tant qu’arguments Object individuels ou en tant que tableau.Since the args parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Exemple : Mise en forme de plus de trois argumentsExample: Formatting more than three arguments

Cet exemple crée une chaîne qui contient des données sur les températures haute et basse à une date particulière.This example creates a string that contains data on the high and low temperature on a particular date. La chaîne de format composite comporte cinq éléments de C# mise en forme dans l’exemple et six dans l’exemple de Visual Basic.The composite format string has five format items in the C# example and six in the Visual Basic example. 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.Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.

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.You can also pass the objects to be formatted as an array rather than as an argument list.

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

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) 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.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

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

Paramètres

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Objet à mettre en forme.The object to format.

Retours

Copie de format dans laquelle le ou les éléments de mise en forme sont remplacés par la représentation sous forme de chaîne de arg0.A copy of format in which the format item or items have been replaced by the string representation of arg0.

Exceptions

format n'est pas valide.format is invalid.

- ou --or- L’index d’un élément de format n’est pas zéro.The index of a format item is not zero.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. 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é.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. La méthode convertit arg0 en sa représentation sous forme de chaîne en appelant sa méthode ToString (IFormatProvider) ou, si l’élément de format correspondant à l’objet comprend une chaîne de format, en appelant sa méthode ToString (String, IFormatProvider) . méthode.The method converts arg0 to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.If these methods don't exist, it calls the object's parameterless ToString method.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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é.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

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

Paramètres

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.An object that supplies culture-specific formatting information.

args
Object[]

Tableau d'objets contenant aucun ou plusieurs objets à mettre en forme.An object array that contains zero or more objects to format.

Retours

Copie de format dans laquelle les éléments de mise en forme ont été remplacés par la représentation sous forme de chaîne des objets correspondants dans args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Exceptions

format n'est pas valide.format is invalid.

ou-or- L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal à la longueur du tableau args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. 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é.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. La méthode convertit Object chaque 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) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.If these methods don't exist, it calls the object's parameterless ToString method.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Exemple : Mise en forme dépendante de la cultureExample: Culture-sensitive formatting

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.This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.

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

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) 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.Replaces the format items in a string with the string representation of two specified objects.

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

Paramètres

arg0
Object Object Object Object

Premier objet à mettre en forme.The first object to format.

arg1
Object Object Object Object

Deuxième objet à mettre en forme.The second object to format.

Retours

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Exceptions

format n'est pas valide.format is invalid.

ou-or- L’index d’un élément de format n’est pas zéro ou un.The index of a format item is not zero or one.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Exemple : Mise en forme de deux argumentsExample: Formatting two arguments

Cet exemple utilise la Format(String, Object, Object) méthode pour afficher les données de temps et de température stockées Dictionary<TKey,TValue> dans un objet générique.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. 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.Note that the format string has three format items, although there are only two objects to format. 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.This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the 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

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) 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.Replaces the format items in a string with the string representation of two specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

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

Paramètres

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Premier objet à mettre en forme.The first object to format.

arg1
Object Object Object Object

Deuxième objet à mettre en forme.The second object to format.

Retours

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0 et arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Exceptions

format n'est pas valide.format is invalid.

- ou --or- L’index d’un élément de format n’est pas zéro ou un.The index of a format item is not zero or one.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. 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é.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. La méthode convertit Object chaque 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) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.If these methods don't exist, it calls the object's parameterless ToString method.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) 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.Replaces the format items in a string with the string representation of three specified objects.

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

Paramètres

arg0
Object Object Object Object

Premier objet à mettre en forme.The first object to format.

arg1
Object Object Object Object

Deuxième objet à mettre en forme.The second object to format.

arg2
Object Object Object Object

Troisième objet à mettre en forme.The third object to format.

Retours

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Exceptions

format n'est pas valide.format is invalid.

- ou --or- L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.The index of a format item is less than zero, or greater than two.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Exemple : Mise en forme de trois argumentsExample: Formatting three 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.This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And operation with two integer values. 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.Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.

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

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) 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.Replaces the format items in a string with the string representation of three specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.An parameter supplies culture-specific formatting information.

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

Paramètres

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Premier objet à mettre en forme.The first object to format.

arg1
Object Object Object Object

Deuxième objet à mettre en forme.The second object to format.

arg2
Object Object Object Object

Troisième objet à mettre en forme.The third object to format.

Retours

Copie de format dans laquelle les éléments de mise en forme sont remplacés par les représentations sous forme de chaîne de arg0, arg1 et arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Exceptions

format n'est pas valide.format is invalid.

- ou --or- L’index d’un élément de format est inférieur à zéro, ou supérieur à deux.The index of a format item is less than zero, or greater than two.

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.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Une chaîne interpolée est une chaîne contenant des expressions interpolées.An interpolated string is a string that contains interpolated expressions. 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.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 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).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

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.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. 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é.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. La méthode convertit Object chaque 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) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Si ces méthodes n’existent pas, elle appelle la méthode ToString sans paramètre de l’objet.If these methods don't exist, it calls the object's parameterless ToString method.

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.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Vous affectez à chaque élément de format un index numérique ; le premier index commence à 0.You assign each format item a numeric index; the first index starts at 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.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 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.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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 ?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

S’applique à