IFormattable IFormattable IFormattable IFormattable Interface

Définition

Fournit les fonctionnalités qui permettent de mettre en forme la valeur d'un objet en une représentation de chaîne.Provides functionality to format the value of an object into a string representation.

public interface class IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
public interface IFormattable
type IFormattable = interface
Public Interface IFormattable
Dérivé
Attributs

Exemples

L'exemple suivant définit une classe Temperature qui implémente l'interface IFormattable .The following example defines a Temperature class that implements the IFormattable interface. 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", 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.The class supports four format specifiers: "G" and "C", which indicate that the temperature is to be displayed in Celsius; "F", which indicates that the temperature is to be displayed in Fahrenheit; and "K", which indicates that the temperature is to be displayed in Kelvin. En outre, l' IFormattable.ToString implémentation peut également gérer une chaîne de format qui null est ou vide.In addition, the IFormattable.ToString implementation also can handle a format string that is null or empty. Les deux ToString autres méthodes définies par la Temperature classe encapsulent simplement un appel IFormattable.ToString à l’implémentation.The other two ToString methods defined by the Temperature class simply wrap a call to the IFormattable.ToString implementation.

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));
      }
   }
}
Imports System.Globalization

Public Class Temperature : Implements IFormattable
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      If temperature < -273.15 Then _ 
        Throw New ArgumentOutOfRangeException(String.Format("{0} is less than absolute zero.", _
                                              temperature))
      Me.temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius As Decimal
      Get
         Return temp
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit As Decimal
      Get
         Return temp * 9 / 5 + 32
      End Get
   End Property
   
   Public ReadOnly Property Kelvin As Decimal
      Get
         Return temp + 273.15d
      End Get
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("G", CultureInfo.CurrentCulture)
   End Function
      
   Public Overloads Function ToString(fmt As String) As String
      Return Me.ToString(fmt, CultureInfo.CurrentCulture)
   End Function
   
   Public Overloads Function ToString(fmt As String, provider As IFormatProvider) _
                   As String _
                   Implements IFormattable.ToString
      If String.IsNullOrEmpty(fmt) Then fmt = "G"
      If provider Is Nothing Then provider = CultureInfo.CurrentCulture
      
      Select Case fmt.ToUpperInvariant()
         Case "G", "C"
            Return temp.ToString("F2", provider) + " °C" 
         Case "F"
            Return Fahrenheit.ToString("F2", provider) + " °F"
         Case "K"
            Return Kelvin.ToString("F2", provider) + " K"
         Case Else
            Throw New FormatException(String.Format("The {0} format string is not supported.", fmt))
      End Select
   End Function
End Class

L’exemple suivant appelle ensuite l' IFormattable.ToString implémentation soit directement, soit à l’aide d’une chaîne de format composite.The following example then calls the IFormattable.ToString implementation either directly or by using a composite format string.

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)
Module Example
   Public Sub Main()
      ' Use composite formatting with format string in the format item.
      Dim temp1 As New Temperature(0)
      Console.WriteLine("{0:C} (Celsius) = {0:K} (Kelvin) = {0:F} (Fahrenheit)", temp1)
      Console.WriteLine()
      
      ' 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)", temp1))
      Console.WriteLine()
      
      ' Call ToString method with format string.
      temp1 = New Temperature(32)
      Console.WriteLine("{0} (Celsius) = {1} (Kelvin) = {2} (Fahrenheit)", _
                        temp1.ToString("C"), temp1.ToString("K"), temp1.ToString("F"))
      Console.WriteLine()

      ' Call ToString with format string and format provider
      temp1 = New Temperature(100)      
      Dim current As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      Dim nl As 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))
   End Sub
End Module
' 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)

Remarques

L' IFormattable interface convertit un objet en sa représentation sous forme de chaîne en fonction d’une chaîne de format et d’un fournisseur de format.The IFormattable interface converts an object to its string representation based on a format string and a format provider.

Une chaîne de format définit généralement l’apparence générale d’un objet.A format string typically defines the general appearance of an object. Par exemple, le .NET Framework prend en charge les éléments suivants:For example, the .NET Framework supports the following:

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.You can also define your own format strings to support formatting of your application-defined types.

Un 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.A format provider returns a formatting object that typically defines the symbols used in converting an object to its string representation. Par exemple, lorsque vous convertissez un nombre en valeur monétaire, un fournisseur de format définit le symbole monétaire qui apparaît dans la chaîne de résultat.For example, when you convert a number to a currency value, a format provider defines the currency symbol that appears in the result string. Le .NET Framework définit trois fournisseurs de format:The .NET Framework defines three format providers:

En outre, vous pouvez définir vos propres fournisseurs de format personnalisés pour fournir des informations spécifiques à la culture, à la profession ou à l’industrie, utilisées dans la mise en forme.In addition, you can define your own custom format providers to supply culture-specific, profession-specific, or industry-specific information used in formatting. Pour plus d’informations sur l’implémentation de la mise en forme personnalisée à l’aide ICustomFormatterd’un fournisseur de format personnalisé, consultez.For more information about implementing custom formatting by using a custom format provider, see ICustomFormatter.

L' IFormattable interface définit une méthode unique, ToString, qui fournit des services de mise en forme pour le type d’implémentation.The IFormattable interface defines a single method, ToString, that supplies formatting services for the implementing type. La ToString méthode peut être appelée directement.The ToString method can be called directly. En outre, il est appelé automatiquement par les Convert.ToString(Object) méthodes Convert.ToString(Object, IFormatProvider) et, et par les méthodes qui utilisent la fonctionnalité de mise en forme composite dans la .NET Framework.In addition, it is called automatically by the Convert.ToString(Object) and Convert.ToString(Object, IFormatProvider) methods, and by methods that use the composite formatting feature in the .NET Framework. Ces méthodes incluent Console.WriteLine(String, Object), String.Format, et StringBuilder.AppendFormat(String, Object), entre autres.Such methods include Console.WriteLine(String, Object), String.Format, and StringBuilder.AppendFormat(String, Object), among others. La ToString méthode est appelée pour chaque élément de mise en forme dans la chaîne de format de la méthode.The ToString method is called for each format item in the method's format string.

L' IFormattable interface est implémentée par les types de données de base.The IFormattable interface is implemented by the base data types.

Notes pour les responsables de l’implémentation

Les classes qui requièrent davantage de contrôle sur la mise en ToString() forme des chaînes IFormattableque ne doit implémenter.Classes that require more control over the formatting of strings than ToString() provides should implement IFormattable.

Une classe qui implémente IFormattable doit prendre en charge le spécificateur de format "G" (général).A class that implements IFormattable must support the "G" (general) format specifier. Outre le spécificateur «G», la classe peut définir la liste des spécificateurs de format qu’elle prend en charge.Besides the "G" specifier, the class can define the list of format specifiers that it supports. En outre, la classe doit être préparée à gérer un spécificateur de format qui est null.In addition, the class must be prepared to handle a format specifier that is null. Pour plus d’informations sur la mise en forme et la mise en forme des codes, consultez mise en forme des typesFor more information about formatting and formatting codes, see Formatting Types

Méthodes

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

Met en forme la valeur de l'instance actuelle à l'aide du format spécifié.Formats the value of the current instance using the specified format.

S’applique à

Voir aussi