Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

String.Format méthode

 

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

Si vous ne connaissez pas le String.Format (méthode), consultez leprise en main de la méthode String.Format section pour une vue d’ensemble rapide.

Consultez le remarques section pour obtenir une documentation complète pour toutes les String.Format surcharges.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

NomDescription
System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(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é.

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

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

Et vous pouvez contrôler la mise en forme de cette valeur :

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
// 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 alignement et l’espacement.

Insertion d’une chaîne

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

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

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

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

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

Vous pouvez avoir autant d’éléments format et qu’un grand nombre d’objets dans la liste d’objets que vous souhaitez, tant que l’index de chaque élément de format a un objet correspondant dans la liste d’objets. Vous n’avez à vous soucier sur quelle surcharge, vous appelez ; le compilateur sélectionne celui qui convient à votre place.

Contrôle de la mise en forme

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

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

Un numéro de prise en charge des types de chaînes de format, y compris tous les types numériques (les deux standard et personnalisé chaînes de format), toutes les dates et heures (les deux standard et personnalisé chaînes de format) et les intervalles de temps (à la fois standard et personnalisé chaînes de format), tous les types énumération types énumération, et GUIDs. Vous pouvez également ajouter la prise en charge des chaînes de format pour vos propres types.

Contrôle de l’espacement

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

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

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,6} {1,15}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{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
Contrôle de l’alignement

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

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

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

String.Formatutilise la fonctionnalité de mise en forme composite. Pour plus d'informations, consultez Mise en forme composite.

Pour plus d’informations sur le choix d’une surcharge, consultez sur lequel la méthode appelez ?

String String.Format(String format, Object arg0)

Remplace les éléments de format par la représentation sous forme de chaîne d’un objet spécifié (exemple).

String String.Format(String format, Object arg0, Object arg1)

Remplace les éléments de format par la représentation sous forme de chaîne de deux objets spécifiés (exemple).

String String.Format(String format, Object arg0, Object arg1, Object arg2)

Remplace les éléments de format par la représentation sous forme de chaîne de trois objets spécifiés (exemple).

String String.Format(String format, params Object[] args)

Remplace les éléments de format par les représentations sous forme de chaîne des objets correspondants dans un tableau spécifié (exemple).

String String.Format(IFormatProvider provider, String format, params Object[] args)

Remplace les éléments de format par la représentation sous forme de chaîne des objets correspondants dans un tableau spécifié et utilise les informations de mise en forme propres à la culture spécifiées (exemple) ou les informations de mise en forme personnalisée (exemple).

Il s’agit d’une liste complète des paramètres pour le Format méthode ; consultez la syntaxe de la surcharge ci-dessus pour les paramètres utilisés par chaque surcharge. Uniquement les format paramètre est utilisé par toutes les surcharges.

Paramètre

Type

Description

format

String

Chaîne de format composite qui inclut un ou plusieurs éléments de format (consultez l’élément de format).

arg0

String

La première ou l’uniquement l’objet à mettre en forme.

arg1

String

Deuxième objet à mettre en forme.

arg2

String

Troisième objet à mettre en forme.

args

String[]

Zéro ou plusieurs objets à mettre en forme fournie dans une liste délimitée par des virgules ou sous forme de tableau.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme personnalisées ou spécifiques à la culture.

Type : String
une copie de format dans laquelle les éléments de forme ont été remplacés par les représentations sous forme de chaîne d’arguments correspondants.

Exception

Condition

Levée par

ArgumentNullException

format a la valeur null.

Toutes les surcharges.

FormatException

format n'est pas valide.

ou

L’index d’un élément de format est inférieur à zéro, ou supérieur ou égal au nombre d’arguments dans la liste d’arguments.

Toutes les surcharges.

Vers

Call

Mettre en forme un ou plusieurs objets en utilisant les conventions de la culture actuelle.

À l’exception des surcharges qui incluent un provider paramètre, les autresFormat surcharges incluent un String paramètre suivie d’un ou plusieurs paramètres de l’objet. Pour cette raison, vous n’avez pas déterminer quelle Format surcharge que vous voulez appeler. Le compilateur de langage sélectionnera la surcharge appropriée parmi les surcharges qui n’ont pas un provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments possède cinq arguments, le compilateur appelle le Format(String, Object[]) (méthode).

Mettre en forme un ou plusieurs objets en utilisant les conventions d’une culture spécifique.

ChaqueFormatsurcharge qui commence par un provider paramètre est suivi d’un String paramètre et la valeur d’un ou plusieurs paramètres de l’objet. Pour cette raison, vous n’avez pas à déterminer quelles Format surcharge que vous voulez appeler. Le compilateur de langage sélectionnera la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments. Par exemple, si votre liste d’arguments possède cinq arguments, le compilateur appelle le Format(IFormatProvider, String, Object[]) (méthode).

Effectuer une opération de mise en forme personnalisée avec un ICustomFormatter implémentation ou un IFormattable mise en œuvre.

Un des quatre surcharges avec un provider paramètre. compilateur sélectionne la surcharge appropriée parmi les surcharges qui ont un provider paramètre, en fonction de votre liste d’arguments.

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

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

Un élément de format a cette syntaxe :


{
index[,alignment][ :formatString] }

Crochets indiquent des éléments facultatifs. Les accolades ouvrantes et fermantes sont requises. (Pour inclure une ouverture littéral ou fermante dans la chaîne de format, consultez la section « Accolades d’échappement » dans la Mise en forme composite article.)

Par exemple, un élément de format au format de que valeur monétaire peut apparaît comme suit :

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

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

index

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

alignement

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

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

formatString

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

Toutefois, notez que n’importe quel type personnalisé peut implémenter IFormattable ou étendre un type existant IFormattable implémentation.

L’exemple suivant utilise le alignment et formatString arguments pour produire le résultat mis en forme.

using System;

public class Example
{
   public static void Main()
   {
      // 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
      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;      
      foreach (var 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 %

Éléments de format sont traités de façon séquentielle à partir du début de la chaîne. Chaque élément de format a un index qui correspond à un objet dans la liste d’arguments de la méthode. Le Format extrait l’argument de méthode et sa représentation sous forme de chaîne est dérivée comme suit :

Pour obtenir un exemple qui intercepte les appels à la ICustomFormatter.Format (méthode) et vous permet de voir les informations le Format méthode passe à une méthode de mise en forme pour chaque élément de format de chaîne de format composite, consultez exemple 7 : un fournisseur de l’ordonnée à l’origine et d’un chiffre romain formateur.

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

public class Example
{
   public static void Main()
   {
      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

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

Le IFormatProvider interface comprend un seul membre, GetFormat, qui est chargé de retourner l’objet qui fournit des informations de mise en forme. Le .NET Framework propose trois IFormatProvider implémentations qui fournissent la mise en forme propres à la culture :

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

  • DateTimeFormatInfo, qui est utilisé pour de mise en forme propres à la culture des valeurs de date et d’heure. Son GetFormat méthode est retournée.

  • NumberFormatInfo, qui est utilisé pour la mise en forme propres à la culture des valeurs numériques. Son GetFormat propriété renvoie elle-même.

Vous pouvez également appeler l’une des surcharges de la Format méthode ayant un provider paramètre Format(IFormatProvider, String, Object[]) surcharge pour effectuer des opérations de mise en forme personnalisées. Par exemple, vous pourriez mettre en forme un nombre entier comme un numéro d’identification ou un numéro de téléphone. Pour effectuer une mise en forme personnalisée, votre provider argument doit implémenter les deux le IFormatProvider et ICustomFormatter interfaces. Lorsque leFormat méthode est passée une ICustomFormatter mise en œuvre en tant que le provider argument, la Format appels de méthode son IFormatProvider.GetFormat implémentation et demande un objet de type ICustomFormatter. Il appelle ensuite retourné ICustomFormatter l’objet Format méthode pour mettre en forme chaque élément de format dans la chaîne composite qui lui sont passés.

Pour plus d’informations sur les solutions de mise en forme personnalisées, consultez Comment : définir et utiliser des fournisseurs de format numérique personnalisés et ICustomFormatter. Pour obtenir un exemple qui convertit des entiers en nombres personnalisé mis en forme, consultez exemple 6 : une opération de mise en forme personnalisée. Pour obtenir un exemple qui convertit les chiffres romains en octets non signés, consultez exemple 7 : un fournisseur de l’ordonnée à l’origine et d’un chiffre romain formateur.

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

using System;

[assembly: CLSCompliant(true)]
public class Example
{
   public static void Main()
   {
      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.

Cet exemple utilise le Format(String, Object, Object) méthode pour afficher les données de temps et de température stockées dans un type générique Dictionary<TKey, TValue> objet. Notez que la chaîne de format a trois éléments de format, bien qu’il existe uniquement deux objets à mettre en forme. Il s’agit, car le premier objet dans la liste (une valeur de date et heure) est utilisé par les deux éléments de format : le premier format élément s’affiche l’heure et la seconde affiche la date.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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 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

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

using System;

public class Example
{
   public static 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)

Cet exemple crée une chaîne qui contient des données sur la température haute et basse à une date particulière. La chaîne de format composite a cinq éléments de format dans l’exemple c# et six dans l’exemple Visual Basic. Deux des éléments de format de définir la largeur de la représentation sous forme de chaîne de leur valeur correspondante, et le premier élément de format inclut également une date standard et la chaîne de format d’heure.

using System;

public class Example
{
   public static void Main()
   {
      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 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’une liste d’arguments.

using System;

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

   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class 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

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 des valeurs numériques à l’aide de plusieurs cultures différentes.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      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)
      {
         CultureInfo culture = new 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

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

using System;

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

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

   public string Format(string format, 
	                     object arg, 
	                     IFormatProvider formatProvider) 
   {                       
      if (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";

         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');

         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

Cet exemple définit un fournisseur de format personnalisé qui implémente le ICustomFormatter et IFormatProvider interfaces faire deux choses :

  • Il affiche les paramètres passés à son ICustomFormatter.Format implémentation. Cela permet de voir quels paramètres le Format(IFormatProvider, String, Object[]) méthode passe à l’implémentation de la mise en forme personnalisée pour chaque objet qu’il tente de mettre en forme. Cela peut être utile lorsque vous déboguez votre application.

  • Si l’objet à mettre en forme est une valeur d’octet non signé qui doit être mise en forme à l’aide de la chaîne de format standard « R », le formateur personnalisé met en forme la valeur numérique en tant qu’un chiffre romain.

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, 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

.NET Framework

Toutes les surcharges sont pris en charge dans : 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Toutes les surcharges sont pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Uniquement Format(String, Object[]) et Format(IFormatProvider, String, Object[]) sont pris en charge

.NET pour les applications du Windows Store

Uniquement Format(String, Object[]) et Format(IFormatProvider, String, Object[]) sont pris en charge dans Windows 8

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

{index[,alignment][: formatString]}

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

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

using System;

public class Example
{
   public static void Main()
   {
      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 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 un 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.

using System;

public class Example
{
   public static void Main()
   {
      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

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

using System;

public class Example
{
   public static void Main()
   {
      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

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 de la « 0 » spécificateur de format numérique personnalisée, comme le montre l’exemple suivant.

using System;

public class Example
{
   public static void Main()
   {
      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

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

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

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

Une seule accolade ouvrante ou fermante est toujours interprétée comme le début ou la fin d’un élément de format. Pour être interprété littéralement, celui-ci doit être échappé. Vous échapper une accolade en ajoutant un autre accolade (« {{ » et «}} » au lieu de » { » et «} »), comme dans l’appel de méthode suivant :

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

Toutefois, les accolades même séquence d’échappement sont facilement mal interprétés. Nous recommandons que vous incluez des accolades dans la liste de format et utilisez des éléments de format pour les insérer dans la chaîne de résultat, comme le montre l’exemple suivant.

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

La cause la plus courante de l’exception est que l’index d’un élément de format ne correspond pas à un objet dans la liste de format. Cela indique généralement que vous avez misnumbered les index des éléments de format ou si vous avez oublié d’inclure un objet dans la liste de format. Parfois, l’exception est le résultat d’une faute de frappe ; par exemple, une erreur classique consiste à une faute de frappe » [« (le crochet gauche) au lieu de « { » (l’accolade gauche).

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

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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);   
   }
}

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

Étant donné que Visual Basic ni c# peut convertir un tableau d’entiers à un tableau d’objets, vous devez effectuer la conversion avant d’appeler le Format(String, Object[]) (méthode). L’exemple suivant fournit une implémentation.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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);   
   }
}
Retour au début
Afficher: