IFormattable IFormattable IFormattable IFormattable Interface

Definición

Proporciona funciones para convertir el valor de un objeto al formato de una representación de cadena.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
Derivado
Atributos

Ejemplos

En el ejemplo siguiente se define una clase Temperature que implementa la interfaz IFormattable .The following example defines a Temperature class that implements the IFormattable interface. La clase admite cuatro especificadores de formato: "G" y "C", que indican que la temperatura se va a mostrar en Celsius; "F", que indica que la temperatura debe mostrarse en grados Fahrenheit; y "K", que indica que la temperatura se va a mostrar 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. Además, la IFormattable.ToString implementación también puede controlar una cadena de formato que es null o está vacía.In addition, the IFormattable.ToString implementation also can handle a format string that is null or empty. Los otros dos ToString métodos definidos por la Temperature clase simplemente encapsulan una llamada a IFormattable.ToString la implementación.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

En el ejemplo siguiente se llama IFormattable.ToString a la implementación directamente o mediante una cadena de formato compuesto.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)

Comentarios

La IFormattable interfaz convierte un objeto en su representación de cadena basándose en una cadena de formato y un proveedor de formato.The IFormattable interface converts an object to its string representation based on a format string and a format provider.

Normalmente, una cadena de formato define la apariencia general de un objeto.A format string typically defines the general appearance of an object. Por ejemplo, el .NET Framework admite lo siguiente:For example, the .NET Framework supports the following:

También puede definir sus propias cadenas de formato para admitir el formato de los tipos definidos por la aplicación.You can also define your own format strings to support formatting of your application-defined types.

Un proveedor de formato devuelve un objeto de formato que normalmente define los símbolos que se usan para convertir un objeto en su representación de cadena.A format provider returns a formatting object that typically defines the symbols used in converting an object to its string representation. Por ejemplo, al convertir un número en un valor de moneda, un proveedor de formato define el símbolo de moneda que aparece en la cadena de resultado.For example, when you convert a number to a currency value, a format provider defines the currency symbol that appears in the result string. El .NET Framework define tres proveedores de formato:The .NET Framework defines three format providers:

Además, puede definir sus propios proveedores de formato personalizado para proporcionar información específica de la referencia cultural, específica de la profesión o específica del sector utilizada en el formato.In addition, you can define your own custom format providers to supply culture-specific, profession-specific, or industry-specific information used in formatting. Para obtener más información sobre cómo implementar el formato personalizado mediante un proveedor de formato ICustomFormatterpersonalizado, vea.For more information about implementing custom formatting by using a custom format provider, see ICustomFormatter.

La IFormattable interfaz define un método único, ToString, que proporciona servicios de formato para el tipo de implementación.The IFormattable interface defines a single method, ToString, that supplies formatting services for the implementing type. Se ToString puede llamar al método directamente.The ToString method can be called directly. Además, los Convert.ToString(Object) métodos y Convert.ToString(Object, IFormatProvider) llaman automáticamente a este método y los métodos que usan la característica de formato compuesto en el .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. Estos métodos incluyen Console.WriteLine(String, Object), String.Formaty StringBuilder.AppendFormat(String, Object), entre otros.Such methods include Console.WriteLine(String, Object), String.Format, and StringBuilder.AppendFormat(String, Object), among others. Se ToString llama al método para cada elemento de formato de la cadena de formato del método.The ToString method is called for each format item in the method's format string.

La IFormattable interfaz la implementan los tipos de datos base.The IFormattable interface is implemented by the base data types.

Notas a los implementadores

Las clases que requieren más control sobre el formato de las ToString() cadenas que proporciona IFormattabledeben implementar.Classes that require more control over the formatting of strings than ToString() provides should implement IFormattable.

Una clase que implementa IFormattable debe admitir el especificador de formato "G" (general).A class that implements IFormattable must support the "G" (general) format specifier. Además del especificador "G", la clase puede definir la lista de especificadores de formato que admite.Besides the "G" specifier, the class can define the list of format specifiers that it supports. Además, la clase debe estar preparada para controlar un especificador de formato que sea null.In addition, the class must be prepared to handle a format specifier that is null. Para obtener más información sobre el formato y los códigos de formato, vea aplicar formato a tiposFor more information about formatting and formatting codes, see Formatting Types

Métodos

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

Aplica formato al valor de la instancia actual utilizando el formato especificado.Formats the value of the current instance using the specified format.

Se aplica a

Consulte también: