Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

IFormattable, interface

Fournit des fonctionnalités permettant de mettre en forme la valeur d'un objet dans une chaîne.

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

[ComVisibleAttribute(true)]
public interface IFormattable

Le type IFormattable expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringMet en forme la valeur de l'instance actuelle à l'aide du format spécifié.
Début

L'interface IFormattable convertit un objet en sa représentation sous forme de chaîne en se fondant sur une chaîne de format et un fournisseur de format.

La chaîne de format définit généralement l'apparence globale d'un objet. Ainsi, le .NET Framework prend en charge les chaînes suivantes :

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.

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

De plus, vous pouvez définir vos propres fournisseurs de format personnalisés pour fournir les informations spécifiques à la culture, à la profession ou à l'industrie utilisées pour 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 ICustomFormatter.

L'interface IFormattable définit une méthode unique, ToString, qui fournit les services de mise en forme liés au type d'implémentation. La méthode ToString peut être appelée directement. De plus, elle est appelée automatiquement par les méthodes Convert.ToString(Object) et Convert.ToString(Object, IFormatProvider), ainsi que par les méthodes qui utilisent la fonctionnalité de mise en forme composite du .NET Framework. Ces méthodes incluent notamment Console.WriteLine(String, Object), String.Format et StringBuilder.AppendFormat(String, Object). La méthode ToString est appelée pour chaque élément de mise en forme de la chaîne de format de la méthode.

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

Remarques à l'attention des implémenteurs

Les classes qui nécessitent plus de contrôle pour la mise en forme des chaînes que n'en fournit Object.ToString doivent implémenter IFormattable.

Une classe implémentant IFormattable doit prendre en charge le spécificateur de format « G » (général). Outre le spécificateur « G », la classe peut définir la liste des spécificateurs de format qu'elle prend en charge. De plus, la classe doit être préparée à gérer un spécificateur de format qui est null. Pour plus d'informations sur la mise en forme et les codes de mise en forme, consultez Mise en forme des types.

L'exemple suivant définit une classe Temperature qui implémente l'interface IFormattable. Cette classe prend en charge quatre spécificateurs de format : « G » et « C », qui indiquent que la température sera affichée en Celsius, « F », qui indique que la température sera affichée en Fahrenheit et « K », qui indique que la température sera affichée en Kelvin. De plus, l'implémentation IFormattable.ToString peut également gérer une chaîne de format qui est null ou vide. Les deux autres méthodes ToString définies par la classe Temperature incluent simplement un appel dans un wrapper à l'implémentation IFormattable.ToString.


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 l'implémentation IFormattable.ToString directement ou 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)


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft