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

IFormattable interface

 

Date de publication : novembre 2016

Fournit les fonctionnalités qui permettent de mettre en forme la valeur d'un objet en une représentation de chaîne.

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

[ComVisibleAttribute(true)]
public interface IFormattable

NomDescription
System_CAPS_pubmethodToString(String, IFormatProvider)

Met en forme la valeur de l’instance actuelle en utilisant le format spécifié.

Le IFormattable interface convertit un objet en sa représentation sous forme de chaîne selon une chaîne de format et un fournisseur de format.

En général, une chaîne de format définit l’aspect général d’un objet. Par exemple, le .NET Framework prend en charge les éléments suivants :

Vous pouvez également définir vos propres chaînes de format pour prendre en charge la mise en forme de vos types définis par l’application.

Un fournisseur de format retourne un objet de mise en forme qui en général définit les symboles utilisés pour convertir un objet en sa représentation sous forme de chaîne. Par exemple, lorsque vous convertissez un nombre en une valeur monétaire, un fournisseur de format définit le symbole de devise qui apparaît dans la chaîne de résultat. Le .NET Framework définit trois fournisseurs de format :

En outre, vous pouvez définir vos propres fournisseurs de format personnalisés pour fournir spécifiques à la culture, profession spécifiques, ou des informations spécifiques de l’industrie utilisés dans la mise en forme. Pour plus d’informations sur l’implémentation de la mise en forme personnalisée à l’aide d’un fournisseur de format personnalisé, consultez la page ICustomFormatter.

Le IFormattable interface définit une méthode unique, ToString, qui fournit des services de mise en forme pour le type d’implémentation. Le ToString méthode peut être appelée directement. En outre, elle est appelée automatiquement par le Convert.ToString(Object) et Convert.ToString(Object, IFormatProvider) méthodes et par les méthodes qui utilisent la la fonctionnalité de mise en forme composite dans le .NET Framework. Ces méthodes incluent Console.WriteLine(String, Object), String.Format, et StringBuilder.AppendFormat(String, Object), entre autres. Le ToString méthode est appelée pour chaque élément de format de chaîne de format de la méthode.

Le IFormattable interface est implémentée par les types de base de données.

Remarques à l’attention des implémenteurs :

Les classes nécessitant davantage de contrôle sur la mise en forme des chaînes que Object.ToString fournit doit implémenter IFormattable.

Une classe qui implémente IFormattable doit de prendre en charge le spécificateur de format (général) « G ». Outre le spécificateur « G », la classe peut définir la liste des spécificateurs de format pris en charge. En outre, la classe doit être préparée à gérer un spécificateur de format est null. Pour plus d’informations sur la mise en forme et les codes de mise en forme, consultez Mise en forme des types dans .NET Framework

L'exemple suivant définit une classe Temperature qui implémente l'interface IFormattable. La classe prend en charge quatre spécificateurs de format : « G » et « C », qui indiquent que la température doit être affichée en degrés Celsius ; « F », ce qui indique que la température doit être affichée en degrés Fahrenheit ; et « K », qui indique que la température doit être affichée en Kelvin. En outre, le IFormattable.ToString implémentation peut également gérer une chaîne de format est null ou vide. Les deux autres ToString méthodes définies par la Temperature classe encapsule simplement un appel à la IFormattable.ToString mise en œuvre.

using System;
using System.Globalization;

public class Temperature : IFormattable
{
   private decimal temp;

   public Temperature(decimal temperature)
   {
      if (temperature < -273.15m) 
        throw new ArgumentOutOfRangeException(String.Format("{0} is less than absolute zero.", 
                                              temperature));
      this.temp = temperature;
   }

   public decimal Celsius
   {
      get { return temp; }
   }

   public decimal Fahrenheit
   {
      get { return temp * 9 / 5 + 32; }
   }

   public decimal Kelvin
   {
      get { return temp + 273.15m; }
   }

   public override string ToString()
   {
      return this.ToString("G", CultureInfo.CurrentCulture);
   }

   public string ToString(string format)
   {
      return this.ToString(format, CultureInfo.CurrentCulture);
   }

   public string ToString(string format, IFormatProvider provider) 
   {
      if (String.IsNullOrEmpty(format)) format = "G";
      if (provider == null) provider = CultureInfo.CurrentCulture;

      switch (format.ToUpperInvariant())
      {
         case "G":
         case "C":
            return temp.ToString("F2", provider) + " °C"; 
         case "F":
            return Fahrenheit.ToString("F2", provider) + " °F";
         case "K":
            return Kelvin.ToString("F2", provider) + " K";
         default:
            throw new FormatException(String.Format("The {0} format string is not supported.", format));
      }
   }
}

L’exemple suivant appelle ensuite le IFormattable.ToString implémentation soit directement, soit en utilisant une chaîne de format composite.

public class Example
{
   public static void Main()
   {
      // Use composite formatting with format string in the format item.
      Temperature temp1 = new Temperature(0);
      Console.WriteLine("{0:C} (Celsius) = {0:K} (Kelvin) = {0:F} (Fahrenheit)\n", temp1);

      // Use composite formatting with a format provider.
      temp1 = new Temperature(-40);
      Console.WriteLine(String.Format(CultureInfo.CurrentCulture, "{0:C} (Celsius) = {0:K} (Kelvin) = {0:F} (Fahrenheit)", temp1));
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "{0:C} (Celsius) = {0:K} (Kelvin) = {0:F} (Fahrenheit)\n", temp1));

      // Call ToString method with format string.
      temp1 = new Temperature(32);
      Console.WriteLine("{0} (Celsius) = {1} (Kelvin) = {2} (Fahrenheit)\n", 
                        temp1.ToString("C"), temp1.ToString("K"), temp1.ToString("F"));

      // Call ToString with format string and format provider
      temp1 = new Temperature(100)      ;
      NumberFormatInfo current = NumberFormatInfo.CurrentInfo;
      CultureInfo nl = new CultureInfo("nl-NL"); 
      Console.WriteLine("{0} (Celsius) = {1} (Kelvin) = {2} (Fahrenheit)", 
                        temp1.ToString("C", current), temp1.ToString("K", current), temp1.ToString("F", current));
      Console.WriteLine("{0} (Celsius) = {1} (Kelvin) = {2} (Fahrenheit)", 
                        temp1.ToString("C", nl), temp1.ToString("K", nl), temp1.ToString("F", nl));
   }
}
// The example displays the following output:
//    0.00 °C (Celsius) = 273.15 K (Kelvin) = 32.00 °F (Fahrenheit)
//    
//    -40.00 °C (Celsius) = 233.15 K (Kelvin) = -40.00 °F (Fahrenheit)
//    -40,00 °C (Celsius) = 233,15 K (Kelvin) = -40,00 °F (Fahrenheit)
//    
//    32.00 °C (Celsius) = 305.15 K (Kelvin) = 89.60 °F (Fahrenheit)
//    
//    100.00 °C (Celsius) = 373.15 K (Kelvin) = 212.00 °F (Fahrenheit)
//    100,00 °C (Celsius) = 373,15 K (Kelvin) = 212,00 °F (Fahrenheit)

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: