Auf Englisch lesen

Freigeben über


IFormattable Schnittstelle

Definition

Stellt Funktionen zum Formatieren des Werts eines Objekts als Zeichenfolgendarstellung bereit.

public interface IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
public interface IFormattable
Abgeleitet
Attribute

Beispiele

Im folgenden Beispiel wird eine Temperature -Klasse definiert, die die IFormattable -Schnittstelle implementiert. Die Klasse unterstützt vier Formatbezeichner: "G" und "C", die angeben, dass die Temperatur in Celsius angezeigt werden soll; "F", das angibt, dass die Temperatur in Fahrenheit angezeigt werden soll; und "K", die angibt, dass die Temperatur in Kelvin angezeigt werden soll. Darüber hinaus kann die IFormattable.ToString Implementierung auch eine Formatzeichenfolge verarbeiten, die leer oder ist null . Die anderen beiden ToString Methoden, die von der Temperature -Klasse definiert werden, umschließen einfach einen Aufruf der IFormattable.ToString -Implementierung.

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

Im folgenden Beispiel wird die IFormattable.ToString Implementierung dann entweder direkt oder mithilfe einer zusammengesetzten Formatzeichenfolge aufgerufen.

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)

Hinweise

Die IFormattable Schnittstelle konvertiert ein Objekt basierend auf einer Formatzeichenfolge und einem Formatanbieter in seine Zeichenfolgendarstellung.

Eine Formatzeichenfolge definiert in der Regel die allgemeine Darstellung eines Objekts. Die .NET Framework unterstützt beispielsweise Folgendes:

Sie können auch eigene Formatzeichenfolgen definieren, um die Formatierung Ihrer anwendungsdefinierten Typen zu unterstützen.

Ein Formatanbieter gibt ein Formatierungsobjekt zurück, das in der Regel die Symbole definiert, die beim Konvertieren eines Objekts in seine Zeichenfolgendarstellung verwendet werden. Wenn Sie beispielsweise eine Zahl in einen Währungswert konvertieren, definiert ein Formatanbieter das Währungssymbol, das in der Ergebniszeichenfolge angezeigt wird. Die .NET Framework definiert drei Formatanbieter:

Darüber hinaus können Sie ihre eigenen benutzerdefinierten Formatanbieter definieren, um kulturspezifische, berufsspezifische oder branchenspezifische Informationen zur Verfügung zu stellen, die in der Formatierung verwendet werden. Weitere Informationen zum Implementieren benutzerdefinierter Formatierungen mithilfe eines benutzerdefinierten Formatanbieters finden Sie unter ICustomFormatter.

Die IFormattable -Schnittstelle definiert eine einzelne Methode, ToString, die Formatierungsdienste für den implementierenden Typ bereitstellt. Die ToString -Methode kann direkt aufgerufen werden. Darüber hinaus wird es automatisch von den Convert.ToString(Object) Methoden und Convert.ToString(Object, IFormatProvider) und von Methoden aufgerufen, die das Feature für zusammengesetzte Formatierung im .NET Framework verwenden. Zu diesen Methoden gehören unter anderem Console.WriteLine(String, Object), String.Formatund StringBuilder.AppendFormat(String, Object). Die ToString -Methode wird für jedes Formatelement in der Formatzeichenfolge der Methode aufgerufen.

Die IFormattable Schnittstelle wird von den Basisdatentypen implementiert.

Hinweise für Ausführende

Klassen, die mehr Kontrolle über die Formatierung von Zeichenfolgen benötigen als ToString() bereitgestellt, sollten implementieren IFormattable.

Eine Klasse, die implementiert IFormattable , muss den Formatbezeichner "G" (allgemein) unterstützen. Neben dem G-Spezifizierer kann die -Klasse die Liste der von ihr unterstützten Formatbezeichner definieren. Darüber hinaus muss die -Klasse für die Verarbeitung eines Formatbezeichners vorbereitet sein, der ist null. Weitere Informationen zu Formatierungs- und Formatierungscodes finden Sie unter Formatierungstypen.

Methoden

ToString(String, IFormatProvider)

Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.

Gilt für:

Produkt Versionen
.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

Weitere Informationen