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 mostrará en Celsius; "F", lo que indica que la temperatura que se mostrará en grados Fahrenheit; y "K", lo que indica que la temperatura que se mostrará en grados 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, el IFormattable.ToString implementación también puede tratar una cadena de formato es null o está vacío.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 el Temperature clase ajustar simplemente una llamada a la IFormattable.ToString 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

El ejemplo siguiente, a continuación, llama el IFormattable.ToString 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

El IFormattable interfaz convierte un objeto en su representación de cadena según 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, .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 usados 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 divisa, 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. .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 específicas de referencias culturales, profesión o específica o información específica de la industria usado 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 la implementación de formato personalizado mediante un proveedor de formato personalizado, consulte ICustomFormatter.For more information about implementing custom formatting by using a custom format provider, see ICustomFormatter.

El 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. El ToString método puede llamarse directamente.The ToString method can be called directly. Además, se llama de forma automática el Convert.ToString(Object) y Convert.ToString(Object, IFormatProvider) métodos y también mediante métodos que usan el característica de formato compuesto en .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.Format, y StringBuilder.AppendFormat(String, Object), entre otros.Such methods include Console.WriteLine(String, Object), String.Format, and StringBuilder.AppendFormat(String, Object), among others. El ToString se llama al método para cada elemento de formato de cadena de formato del método.The ToString method is called for each format item in the method's format string.

El IFormattable interfaz se implementa mediante los tipos de base de datos.The IFormattable interface is implemented by the base data types.

Notas a los implementadores

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

Una clase que implementa IFormattable debe ser compatible con el especificador de formato (general) de "G".A class that implements IFormattable must support the "G" (general) format specifier. El especificador "G", además de 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 es 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 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)

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

Se aplica a

Consulte también: