Ler en inglés

Compartir por

IFormattable Interfaz

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Proporciona funciones para convertir el valor de un objeto al formato de una representación de cadena.

C# 
public interface IFormattable
C# 
[System.Runtime.InteropServices.ComVisible(true)]
public interface IFormattable
Derivado
Atributos
ComVisibleAttribute

Ejemplos

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 Celsius; "F", que indica que la temperatura se va a mostrar en Fahrenheit; y "K", que indica que la temperatura se va a mostrar en Kelvin. Además, la IFormattable.ToString implementación también puede controlar una cadena de formato que es o está null vacía. Los otros dos ToString métodos definidos por la Temperature clase simplemente encapsulan una llamada a la IFormattable.ToString implementación.

C# 
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));
      }
   }
}

A continuación, en el ejemplo siguiente se llama a la IFormattable.ToString implementación directamente o mediante una cadena de formato compuesto.

C# 
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)

Comentarios

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

Normalmente, una cadena de formato define la apariencia general de un objeto. Por ejemplo, .NET Framework admite lo siguiente:

También puede definir sus propias cadenas de formato para admitir 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 utilizados para convertir un objeto en su representación de cadena. 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. .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 cultura, específica de la profesión o específica del sector que se usa en el formato. Para obtener más información sobre cómo implementar el formato personalizado mediante un proveedor de formato personalizado, vea ICustomFormatter.

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

Los tipos de datos base implementan la IFormattable interfaz .

Notas a los implementadores

Las clases que requieren más control sobre el formato de las cadenas que ToString() proporciona deben 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 el formato y los códigos de formato, vea Aplicar formato a tipos.

Métodos

ToString(String, IFormatProvider)

Da formato al valor de la instancia actual usando el formato especificado.

Se aplica a

Produto Versións
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

Consulte también