Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

IFormattable-Schnittstelle

Stellt Funktionen bereit, mit denen der Wert eines Objekts in eine Zeichenfolgenentsprechung formatiert werden kann.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IFormattable

Der IFormattable-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringFormatiert den Wert der aktuellen Instanz unter Verwendung des angegebenen Formats.
Zum Seitenanfang

Die IFormattable-Schnittstelle konvertiert ein Objekt in die zugehörige Zeichenfolgendarstellung basierend auf einer Formatzeichenfolge und einem Formatanbieter.

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

Sie können auch eigene Formatzeichenfolgen definieren, um das Formatieren von 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 die zugehörige Zeichenfolgendarstellung verwendet werden. Wenn Sie z. B. eine Zahl in einen Währungswert konvertieren, definiert ein Formatanbieter das Währungssymbol, das in der Ergebniszeichenfolge angezeigt wird. .NET Framework definiert drei Formatanbieter:

Darüber hinaus können Sie eigene benutzerdefinierte Formatanbieter definieren, um kulturspezifische, berufsspezifische oder branchenspezifische Informationen anzugeben, die bei der Formatierung verwendet werden. Weitere Informationen zum Implementieren von benutzerdefinierter Formatierung mit einem benutzerdefinierten Formatanbieter finden Sie unter ICustomFormatter.

Die IFormattable-Schnittstelle definiert eine einzelne Methode, ToString, die Formatierungsdienste für den implementierenden Typ liefert. Die ToString-Methode kann direkt aufgerufen werden. Außerdem wird sie automatisch von der Convert.ToString(Object)-Methode und Convert.ToString(Object, IFormatProvider)-Methode aufgerufen sowie von Methoden, die das Feature für kombinierte Formatierung in .NET Framework verwenden. Dies umfasst beispielsweise die Methoden Console.WriteLine(String, Object), String.Format und StringBuilder.AppendFormat(String, Object). Die ToString-Methode wird für jedes Formatelement in der kombinierten Formatzeichenfolge der Methode aufgerufen.

Die IFormattable-Schnittstelle wird von den Basisdatentypen implementiert.

Hinweise zur Implementierung

Für Klassen, die mehr Steuerung über die Formatierung von Zeichenfolgen erfordern als durch Object.ToString bereitgestellt wird, sollte IFormattable implementiert werden.

Eine Klasse, die IFormattable implementiert, muss den Formatbezeichner "G" (general) unterstützen. Außer dem "G"-Spezifizierer kann die Klasse eine Liste von unterstützten Formatspezifizierern definieren. Außerdem muss die Klasse auf die Behandlung des Formatbezeichners null vorbereitet sein. Weitere Informationen über Formatierung und Formatierungscodes finden Sie unter Formatierung von Typen.

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", der angibt, dass die Temperatur in Fahrenheit angezeigt werden soll, und "K", der angibt, dass die Temperatur in Kelvin angezeigt werden soll. Darüber hinaus kann die IFormattable.ToString-Implementierung auch eine Formatzeichenfolge behandeln, die null oder leer ist. Die anderen zwei von der Temperature-Klasse definierten ToString-Methoden umschließen einfach einen Aufruf zur 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 dann die IFormattable.ToString-Implementierung entweder direkt oder über eine kombinierte 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)


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: 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 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft