Ler em inglês

Partilhar via


IFormattable Interface

Definição

Fornece funcionalidade para formatar o valor de um objeto em uma representação de cadeia de caracteres.

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

Exemplos

O exemplo a seguir define uma classe Temperature que implementa a interface IFormattable. A classe dá suporte a quatro especificadores de formato: "G" e "C", que indicam que a temperatura deve ser exibida em Celsius; "F", que indica que a temperatura deve ser exibida em Fahrenheit; e "K", que indica que a temperatura deve ser exibida em Kelvin. Além disso, a IFormattable.ToString implementação também pode manipular uma cadeia de caracteres de formato ou null vazia. Os outros dois ToString métodos definidos pela Temperature classe simplesmente encapsulam uma chamada para a IFormattable.ToString implementação.

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

O exemplo a seguir chama a IFormattable.ToString implementação diretamente ou usando uma cadeia de caracteres de formato composto.

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)

Comentários

A IFormattable interface converte um objeto em sua representação de cadeia de caracteres com base em uma cadeia de caracteres de formato e um provedor de formato.

Uma cadeia de caracteres de formato normalmente define a aparência geral de um objeto. Por exemplo, o .NET Framework dá suporte ao seguinte:

Você também pode definir suas próprias cadeias de caracteres de formato para dar suporte à formatação de seus tipos definidos pelo aplicativo.

Um provedor de formato retorna um objeto de formatação que normalmente define os símbolos usados na conversão de um objeto em sua representação de cadeia de caracteres. Por exemplo, quando você converte um número em um valor de moeda, um provedor de formato define o símbolo de moeda que aparece na cadeia de caracteres de resultado. O .NET Framework define três provedores de formato:

Além disso, você pode definir seus próprios provedores de formato personalizado para fornecer informações específicas da cultura, específicas da profissão ou específicas do setor usadas na formatação. Para obter mais informações sobre como implementar a formatação personalizada usando um provedor de formato personalizado, consulte ICustomFormatter.

A IFormattable interface define um único método, ToString, que fornece serviços de formatação para o tipo de implementação. O ToString método pode ser chamado diretamente. Além disso, ele é chamado automaticamente pelos Convert.ToString(Object) métodos e Convert.ToString(Object, IFormatProvider) e por métodos que usam o recurso de formatação composta no .NET Framework. Esses métodos incluem Console.WriteLine(String, Object), String.Formate StringBuilder.AppendFormat(String, Object), entre outros. O ToString método é chamado para cada item de formato na cadeia de caracteres de formato do método.

A IFormattable interface é implementada pelos tipos de dados base.

Notas aos Implementadores

Classes que exigem mais controle sobre a formatação de cadeias de caracteres do que ToString() as fornecidas devem implementar IFormattable.

Uma classe que implementa IFormattable deve dar suporte ao especificador de formato "G" (geral). Além do especificador "G", a classe pode definir a lista de especificadores de formato compatíveis. Além disso, a classe deve estar preparada para lidar com um especificador de formato que seja null. Para obter mais informações sobre formatação e formatação de códigos, consulte Tipos de formatação

Métodos

ToString(String, IFormatProvider)

Formata o valor da instância atual usando o formato especificado.

Aplica-se a

Produto Versões
.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

Confira também