IFormattable (Interfaz)

La interfaz IFormattable convierte un objeto en su representación de cadena en función de una cadena de formato y un proveedor de formato.

Una cadena de formato normalmente define el aspecto general de un objeto. Por ejemplo, .NET Framework admite las siguientes cadenas:

• Cadenas con formato estándar para dar formato a valores de enumeración (vea Cadenas de formato de enumeración).

• Cadenas con formato personalizado y estándar para dar formato a valores numéricos (vea Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado).

• Cadenas con formato estándar y personalizado para dar formato a los valores de fecha y hora, (vea Cadenas con formato de fecha y hora estándar y Cadenas de formato de fecha y hora personalizadas).

• Cadenas con formato estándar y personalizado para dar formato a los intervalos de tiempo, (vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizado).

También puede definir sus propias cadenas de formato para proporcionar compatibilidad con el formato de los tipos definidos por la aplicación.

Un proveedor de formato devuelve un objeto de formato que normalmente define los símbolos que se utilizan para convertir un objeto en su representación de cadena. Por ejemplo, cuando un número se convierte en un valor de divisa, un proveedor de formato define el símbolo de divisa que aparece en la cadena resultante. .NET Framework define tres proveedores de formato:

• La clase System.Globalization.CultureInfo, que devuelve un objeto NumberFormatInfo para dar formato a valores numéricos o un objeto DateTimeFormatInfo para dar formato a valores de fecha y hora.

• La clase System.Globalization.NumberFormatInfo, que devuelve una instancia de sí misma para dar formato a valores numéricos.

• La clase System.Globalization.DateTimeFormatInfo, que devuelve una instancia de sí misma para dar formato a valores de fecha y hora.

Además, puede definir sus propios proveedores de formato personalizado para proporcionar información específica de la referencia cultural, de la profesión o de la industria que se utiliza en las operaciones de formato. Para obtener más información sobre la implementación de formatos personalizados mediante un proveedor de formato personalizado, vea ICustomFormatter.

La interfaz IFormattable define un único método, ToString, que proporciona los servicios de formato del tipo de implementación. Se puede llamar directamente al método ToString. Además, a este método lo llaman automáticamente los métodos Convert.ToString(Object) y Convert.ToString(Object, IFormatProvider) y los métodos que utilizan la característica de formato compuesto de .NET Framework. Entre estos métodos se incluyen Console.WriteLine(String, Object), String.Format y StringBuilder.AppendFormat(String, Object). El método ToString se llama para cada elemento de formato de la cadena de formato del método.

Los tipos de datos base implementan la interfaz IFormattable.

Las clases que requieren mayor control sobre el formato que se aplica a las cadenas que el que proporciona Object.ToString deberían implementar IFormattable.

Una clase que implementa IFormattable debe admitir el especificador de formato "G" (general). Además del especificador "G", la clase puede definir la lista de especificadores de formato que admite. Además, la clase debe estar preparada para controlar un especificador de formato que sea null. Para obtener más información sobre formato y códigos de formato, vea Aplicar formato a tipos

En el ejemplo siguiente se define una clase Temperature que implementa la interfaz IFormattable. La clase admite cuatro especificadores de formato: "G" y "C", que indican que la temperatura se va a mostrar en grados Celsius; "F", que indica que la temperatura se va a mostrar en grados Fahrenheit, y "K", que indica que la temperatura se va a mostrar en grados Kelvin. Además, la implementación de IFormattable.ToString también puede administrar una cadena de formato que sea null o esté vacía. Los otros dos métodos ToString definidos por la clase Temperature encapsulan una llamada a la implementación 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));
      }
   }
}

En el ejemplo siguiente, se llama a la implementación IFormattable.ToString directamente o utilizando una cadena de formato compuesta.

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

.NET Framework Client Profile

Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

Referencia

Otros recursos