¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

IFormattable (Interfaz)

Proporciona funcionalidad para dar formato al valor de un objeto en una representación de cadena.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IFormattable

El tipo IFormattable expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToStringAplica formato al valor de la instancia actual utilizando el formato especificado.
Arriba

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:

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:

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.

Notas para los implementadores

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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: 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 (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)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft