Formatieren von Typen in .NETFormatting Types in .NET

Bei der Formatierung wird eine Instanz einer Klasse, Struktur oder eines Enumerationswerts in die entsprechende Zeichenfolgendarstellung konvertiert. Die resultierende Zeichenfolge kann dann häufig Benutzern angezeigt oder sie kann deserialisiert werden, um den ursprünglichen Datentyp wiederherzustellen.Formatting is the process of converting an instance of a class, structure, or enumeration value to its string representation, often so that the resulting string can be displayed to users or deserialized to restore the original data type. Diese Konvertierung kann eine Reihe von Problemen beinhalten:This conversion can pose a number of challenges:

  • Die Art, wie diese Werte intern gespeichert werden, spiegelt nicht notwendigerweise die Art wider, wie die Benutzer sie anzeigen möchten.The way that values are stored internally does not necessarily reflect the way that users want to view them. Eine Telefonnummer könnte beispielsweise wie folgt gespeichert werden: 8009999999. Dies ist jedoch wenig benutzerfreundlich.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Stattdessen sollte die Telefonnummer wie folgt angezeigt werden: 800-999-9999.It should instead be displayed as 800-999-9999. Ein Beispiel für die Formatierung einer Zahl auf diese Weise finden Sie im Abschnitt Benutzerdefinierte Formatzeichenfolgen .See the Custom Format Strings section for an example that formats a number in this way.

  • Manchmal ist die Konvertierung eines Objekts in seine Zeichenfolgendarstellung nicht intuitiv.Sometimes the conversion of an object to its string representation is not intuitive. Beispielsweise ist nicht klar, wie die Zeichenfolgendarstellung eines Temperature-Objekts oder eines Person-Objekts aussehen sollte.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Ein Beispiel für die Formatierung eines Temperature-Objekts auf verschiedene Weise finden Sie im Abschnitt Standardformatzeichenfolgen .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • Oft ist für Werte eine kulturabhängige Formatierung erforderlich.Values often require culture-sensitive formatting. In einer Anwendung, die zum Darstellen von Währungswerten Zahlen verwendet, sollten numerische Zeichenfolgen beispielsweise das Währungssymbol der aktuellen Kultur, das Gruppentrennzeichen (in den meisten Kulturen das Tausendertrennzeichen) und das Dezimaltrennzeichen einschließen.For example, in an application that uses numbers to reflect monetary values, numeric strings should include the current culture’s currency symbol, group separator (which, in most cultures, is the thousands separator), and decimal symbol. Ein Beispiel finden Sie im Abschnitt Kulturabhängige Formatierung mit Formatanbietern und der IFormatProvider-Schnittstelle .For an example, see the Culture-Sensitive Formatting with Format Providers and the IFormatProvider Interface section.

  • Unter Umständen muss ein Wert in einer Anwendung auf unterschiedliche Arten angezeigt werden.An application may have to display the same value in different ways. Beispielsweise stellt eine Anwendung einen Enumerationsmember möglicherweise dar, indem eine Zeichenfolgendarstellung des Namens oder des zugrunde liegende Werts angezeigt wird.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Ein Beispiel für die Formatierung eines Members der DayOfWeek -Enumeration auf unterschiedliche Weise finden Sie im Abschnitt Standardformatzeichenfolgen .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Hinweis

Durch das Formatieren wird der Wert eines Typs in eine Zeichenfolgendarstellung konvertiert.Formatting converts the value of a type into a string representation. Die Analyse ist die Umkehroperation zum Formatieren.Parsing is the inverse of formatting. In einem Analysevorgang wird eine Instanz eines Datentyps aus seiner Zeichenfolgendarstellung erstellt.A parsing operation creates an instance of a data type from its string representation. Informationen zum Konvertieren von Zeichenfolgen in andere Datentypen finden Sie unter Parsing Strings.For information about converting strings to other data types, see Parsing Strings.

.NET bietet eine umfangreiche Formatierungsunterstützung, die es Entwicklern ermöglicht, diese Anforderungen zu erfüllen..NET provides rich formatting support that enables developers to address these requirements.

Diese Übersicht enthält folgende Abschnitte:This overview contains the following sections:

Formatierung in .NETFormatting in .NET

Der grundlegende Mechanismus für die Formatierung ist die Standardimplementierung der Object.ToString-Methode, die im Abschnitt Standardformatierung mit der ToString-Methode später in diesem Thema erläutert wird.The basic mechanism for formatting is the default implementation of the Object.ToString method, which is discussed in the Default Formatting Using the ToString Method section later in this topic. .NET bietet jedoch mehrere Möglichkeiten, die Standardformatierungsunterstützung zu ändern und zu erweitern.However, .NET provides several ways to modify and extend its default formatting support. Hierzu gehört Folgendes:These include the following:

  • Überschreiben der Object.ToString-Methode, um eine benutzerdefinierte Zeichenfolgendarstellung für den Wert eines Objekts zu definieren.Overriding the Object.ToString method to define a custom string representation of an object’s value. Weitere Information erhalten Sie im Abschnitt Überschreiben der ToString-Methode später in diesem Thema.For more information, see the Overriding the ToString Method section later in this topic.

  • Definieren von Formatbezeichnern, die es ermöglichen, dass die Zeichenfolgendarstellung des Werts eines Objekts mehrere Formate annehmen kann.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. Der Formatbezeichner "X" in der folgenden Anweisung konvertiert beispielsweise eine ganze Zahl in die Zeichenfolgendarstellung eines Hexadezimalwerts.For example, the "X" format specifier in the following statement converts an integer to the string representation of a hexadecimal value.

    int integerValue = 60312;
    Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.
    
    Dim integerValue As Integer = 60312
    Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.
    

    Weitere Informationen zu Formatbezeichnern finden Sie im Abschnitt ToString-Methode und Formatzeichenfolgen .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Verwenden von Formatanbietern, die Formatierungskonventionen einer bestimmten Kultur nutzen.Using format providers to take advantage of the formatting conventions of a specific culture. Beispielsweise zeigt die folgende Anweisung einen Währungswert unter Verwendung der Formatierungskonventionen der Kultur en-US an.For example, the following statement displays a currency value by using the formatting conventions of the en-US culture.

    double cost = 1632.54; 
    Console.WriteLine(cost.ToString("C", 
                      new System.Globalization.CultureInfo("en-US")));   
    // The example displays the following output:
    //       $1,632.54
    
    Dim cost As Double = 1632.54
    Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
    ' The example displays the following output:
    '       $1,632.54
    

    Weitere Informationen zum Formatieren mit Formatanbietern finden Sie im Abschnitt Formatanbieter und die IFormatProvider-Schnittstelle .For more information about formatting with format providers, see the Format Providers and the IFormatProvider Interface section.

  • Implementieren der IFormattable -Schnittstelle zur Unterstützung der Zeichenfolgenkonvertierung mit der Convert -Klasse sowie der kombinierten Formatierung.Implementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Weitere Informationen finden Sie im Abschnitt IFormattable-Schnittstelle .For more information, see the IFormattable Interface section.

  • Verwenden der kombinierten Formatierung, um die Zeichenfolgendarstellung eines Werts in einer größeren Zeichenfolge einzubetten.Using composite formatting to embed the string representation of a value in a larger string. Weitere Informationen finden Sie im Abschnitt Kombinierte Formatierung .For more information, see the Composite Formatting section.

  • Implementieren von ICustomFormatter und IFormatProvider , um eine vollständige benutzerdefinierte Formatierungslösung bereitzustellen.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Weitere Informationen finden Sie im Abschnitt Benutzerdefinierte Formatierung mit ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

In den folgenden Abschnitten werden diese Methoden zum Konvertieren eines Objekts in seine Zeichenfolgendarstellung ausführlicher erläutert.The following sections examine these methods for converting an object to its string representation.

Zurück nach obenBack to top

Standardformatierung mit der ToString-MethodeDefault Formatting Using the ToString Method

Jeder von System.Object abgeleitete Typ erbt automatisch eine parameterlose ToString-Methode, die standardmäßig den Namen des Typs zurückgibt.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. Das folgende Beispiel veranschaulicht die ToString -Standardmethode.The following example illustrates the default ToString method. Dabei wird eine Klasse mit dem Namen Automobile ohne Implementierung definiert.It defines a class named Automobile that has no implementation. Wenn die Klasse instanziiert und die zugehörige ToString -Methode aufgerufen wird, wird der Typname angezeigt.When the class is instantiated and its ToString method is called, it displays its type name. Beachten Sie, dass die ToString-Methode im Beispiel nicht explizit aufgerufen wird.Note that the ToString method is not explicitly called in the example. Die Console.WriteLine(Object)-Methode ruft implizit die ToString-Methode des Objekts auf, das ihr als Argument übergeben wird.The Console.WriteLine(Object) method implicitly calls the ToString method of the object passed to it as an argument.

using System;

public class Automobile
{
   // No implementation. All members are inherited from Object.
}

public class Example
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile
Public Class Automobile
   ' No implementation. All members are inherited from Object.
End Class

Module Example
   Public Sub Main()
      Dim firstAuto As New Automobile()
      Console.WriteLine(firstAuto)
   End Sub
End Module
' The example displays the following output:
'       Automobile

Warnung

Ab Windows 8.1Windows 8.1enthält Windows-RuntimeWindows Runtime eine IStringable -Schnittstelle mit einer einzelnen Methode, IStringable.ToString, die eine Standardformatierungsunterstützung bereitstellt.Starting with Windows 8.1Windows 8.1, the Windows-RuntimeWindows Runtime includes an IStringable interface with a single method, IStringable.ToString, which provides default formatting support. Es wird jedoch empfohlen, dass verwaltete Typen die IStringable -Schnittstelle nicht implementieren.However, we recommend that managed types do not implement the IStringable interface. Weitere Informationen finden Sie im Abschnitt "Windows-RuntimeWindows Runtime und die IStringable-Schnittstelle" auf der Object.ToString-Referenzseite.For more information, see "The Windows-RuntimeWindows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Da alle anderen Typen außer Schnittstellen von Objectabgeleitet werden, wird diese Funktionalität automatisch für die benutzerdefinierten Klassen oder Strukturen bereitgestellt.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. Die Funktionalität der ToString -Standardmethode ist jedoch begrenzt: Sie identifiziert zwar den Typ, stellt jedoch keine Informationen zu einer Instanz des Typs bereit.However, the functionality offered by the default ToString method, is limited: Although it identifies the type, it fails to provide any information about an instance of the type. Um eine Zeichenfolgendarstellung eines Objekts bereitzustellen, die Informationen zum Objekt enthält, müssen Sie die ToString -Methode überschreiben.To provide a string representation of an object that provides information about that object, you must override the ToString method.

Hinweis

Strukturen erben vom ValueType, der von Objectabgeleitet wird.Structures inherit from ValueType, which in turn is derived from Object. Auch wenn ValueType von Object.ToString überschrieben wird, ist die Implementierung identisch.Although ValueType overrides Object.ToString, its implementation is identical.

Zurück nach obenBack to top

Überschreiben der ToString-MethodeOverriding the ToString Method

Das Anzeigen des Namens eines Typs ist oft nur von geringem Nutzen und ermöglicht Consumern der Typen keine Unterscheidung zwischen den einzelnen Instanzen.Displaying the name of a type is often of limited use and does not allow consumers of your types to differentiate one instance from another. Sie können jedoch die ToString -Methode überschreiben, um eine nützlichere Darstellung eines Objektwerts bereitzustellen.However, you can override the ToString method to provide a more useful representation of an object’s value. Im folgenden Beispiel wird ein Temperature -Objekt definiert und die ToString -Methode wird überschrieben, um die Temperatur in Grad Celsius anzuzeigen.The following example defines a Temperature object and overrides its ToString method to display the temperature in degrees Celsius.

using System;

public class Temperature
{
   private decimal temp;
   
   public Temperature(decimal temperature)
   {
      this.temp = temperature;   
   }

   public override string ToString()
   {
      return this.temp.ToString("N1") + "°C";
   }
}

public class Example
{
   public static void Main()
   {
      Temperature currentTemperature = new Temperature(23.6m);
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString());
   }
}
// The example displays the following output:
//       The current temperature is 23.6°C.
Public Class Temperature
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.temp = temperature
   End Sub
   
   Public Overrides Function ToString() As String
      Return Me.temp.ToString("N1") + "°C"   
   End Function
End Class

Module Example
   Public Sub Main()
      Dim currentTemperature As New Temperature(23.6d)
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString())
   End Sub
End Module
' The example displays the following output:
'       The current temperature is 23.6°C.

In .NET wurde die ToString-Methode jedes primitiven Werttyps überschrieben, um den Wert des Objekts statt seines Namens anzuzeigen.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. In der folgenden Tabelle wird die Überschreibung für den jeweiligen primitiven Typ angezeigt.The following table shows the override for each primitive type. Beachten Sie, dass die meisten der überschriebenen Methoden eine andere Überladung der ToString -Methode aufrufen und dabei den Formatbezeichner G übergeben, der das allgemeine Format des Typs definiert, sowie ein IFormatProvider -Objekt, das die aktuelle Kultur darstellt.Note that most of the overridden methods call another overload of the ToString method and pass it the "G" format specifier, which defines the general format for its type, and an IFormatProvider object that represents the current culture.

TypType ToString-ÜberschreibungToString override
Boolean Gibt entweder Boolean.TrueString oder Boolean.FalseString zurück.Returns either Boolean.TrueString or Boolean.FalseString.
Byte Ruft Byte.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Byte -Wert für die aktuelle Kultur zu formatieren.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Gibt das Zeichen als Zeichenfolge zurück.Returns the character as a string.
DateTime Ruft DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) auf, um den Datums- und Uhrzeitwert für die aktuelle Kultur zu formatieren.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Ruft Decimal.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Decimal -Wert für die aktuelle Kultur zu formatieren.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Ruft Double.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Double -Wert für die aktuelle Kultur zu formatieren.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Ruft Int16.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Int16 -Wert für die aktuelle Kultur zu formatieren.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Ruft Int32.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Int32 -Wert für die aktuelle Kultur zu formatieren.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Ruft Int64.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Int64 -Wert für die aktuelle Kultur zu formatieren.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Ruft SByte.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den SByte -Wert für die aktuelle Kultur zu formatieren.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Ruft Single.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den Single -Wert für die aktuelle Kultur zu formatieren.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Ruft UInt16.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den UInt16 -Wert für die aktuelle Kultur zu formatieren.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Ruft UInt32.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den UInt32 -Wert für die aktuelle Kultur zu formatieren.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Ruft UInt64.ToString("G", NumberFormatInfo.CurrentInfo) auf, um den UInt64 -Wert für die aktuelle Kultur zu formatieren.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Zurück nach obenBack to top

ToString-Methode und FormatzeichenfolgenThe ToString Method and Format Strings

Wenn ein Objekt über eine einzelne Zeichenfolgendarstellung verfügt, ist das Verwenden der ToString -Standardmethode oder das Überschreiben von ToString angemessen.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Der Wert eines Objekts weist jedoch häufig mehrere Darstellungen auf.However, the value of an object often has multiple representations. Beispielsweise kann die Temperatur in Grad Fahrenheit, Grad Celsius oder Kelvin ausgedrückt werden.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. Entsprechend kann der ganzzahlige Wert 10 unterschiedlich dargestellt werden, z. B. als 10, 10.0, 1.0e01 oder $10.00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Damit ein einzelner Wert mehrere Zeichenfolgendarstellungen aufweisen kann, verwendet .NET Formatzeichenfolgen.To enable a single value to have multiple string representations, .NET uses format strings. Eine Formatzeichenfolge ist eine Zeichenfolge, die einen oder mehrere vordefinierte Formatbezeichner enthält. Dies sind einzelne Zeichen oder Gruppen von Zeichen, die definieren, wie die ToString -Methode die Ausgabe formatieren soll.A format string is a string that contains one or more predefined format specifiers, which are single characters or groups of characters that define how the ToString method should format its output. Die Formatzeichenfolge wird dann als Parameter an die ToString -Methode des Objekts übergeben und bestimmt, wie die Zeichenfolgendarstellung des Werts dieses Objekts angezeigt werden soll.The format string is then passed as a parameter to the object's ToString method and determines how the string representation of that object's value should appear.

Alle numerischen Typen sowie die Datums- und Uhrzeittypen und die Enumerationstypen in .NET unterstützen einen vordefinierten Satz von Formatbezeichnern.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. Sie können auch Formatzeichenfolgen verwenden, um mehrere Zeichenfolgendarstellungen der anwendungsdefinierten Datentypen zu definieren.You can also use format strings to define multiple string representations of your application-defined data types.

StandardformatzeichenfolgenStandard Format Strings

Standardformatzeichenfolgen enthalten einen einzelnen Formatbezeichner. Dabei handelt es sich um ein alphabetisches Zeichen, das die Zeichenfolgendarstellung des Objekts definiert, auf das es angewendet wird. Außerden enthalten sie einen optionalen Genauigkeitsbezeichner, der angibt, wie viele Stellen in der Ergebniszeichenfolge angezeigt werden.A standard format string contains a single format specifier, which is an alphabetic character that defines the string representation of the object to which it is applied, along with an optional precision specifier that affects how many digits are displayed in the result string. Wenn der Genauigkeitsbezeichner nicht angegeben oder nicht unterstützt wird, entspricht ein Standardformatbezeichner einer Standardformatzeichenfolge.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

.NET definiert einen Satz von Standardformatbezeichnern für alle numerischen Typen, alle Datums- und Uhrzeittypen und alle Enumerationstypen..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Beispielsweise definieren die einzelnen Kategorien den Standardformatbezeichner "G", der eine allgemeine Zeichenfolgendarstellung für einen Wert dieses Typs definiert.For example, each of these categories supports a "G" standard format specifier, which defines a general string representation of a value of that type.

Standardformatzeichenfolgen für Enumerationstypen steuern die Zeichenfolgendarstellung eines Werts direkt.Standard format strings for enumeration types directly control the string representation of a value. Die an die ToString-Methode eines Enumerationswerts übergebenen Formatzeichenfolgen bestimmen, ob der Wert mit seinem Zeichenfolgennamen (Formatbezeichner "G" und "F"), seinem zugrunde liegenden ganzzahligen Wert (Formatbezeichner "D") oder seinem Hexadezimalwert (Formatbezeichner "X") angezeigt wird.The format strings passed to an enumeration value’s ToString method determine whether the value is displayed using its string name (the "G" and "F" format specifiers), its underlying integral value (the "D" format specifier), or its hexadecimal value (the "X" format specifier). Im folgenden Beispiel wird die Verwendung von Standardformatzeichenfolgen zum Formatieren eines DayOfWeek -Enumerationswerts veranschaulicht.The following example illustrates the use of standard format strings to format a DayOfWeek enumeration value.

DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001
Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

For Each formatString As String In formatStrings
   Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
'       Monday
'       Monday
'       1
'       00000001

Weitere Informationen über Enumerationsformatzeichenfolgen finden Sie unter Enumeration Format Strings.For information about enumeration format strings, see Enumeration Format Strings.

Standardformatzeichenfolgen für numerische Typen definieren normalerweise eine Ergebniszeichenfolge, deren genaue Darstellung von einem oder mehreren Eigenschaftswerten gesteuert wird.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. Beispielsweise formatiert der Formatbezeichner "C" eine Zahl als Währungswert.For example, the "C" format specifier formats a number as a currency value. Wenn Sie die ToString -Methode mit dem Formatbezeichner "C" als einzigem Parameter aufrufen, werden die folgenden Eigenschaftswerte des NumberFormatInfo -Objekts der aktuellen Kultur verwendet, um die Zeichenfolgendarstellung des numerischen Werts zu definieren:When you call the ToString method with the "C" format specifier as the only parameter, the following property values from the current culture’s NumberFormatInfo object are used to define the string representation of the numeric value:

  • Die CurrencySymbol -Eigenschaft, die das Währungssymbol der aktuellen Kultur angibt.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • Die CurrencyNegativePattern -Eigenschaft oder die CurrencyPositivePattern -Eigenschaft, die eine ganz Zahl zurückgeben, die Folgendes bestimmt:The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • Die Platzierung des Währungssymbols.The placement of the currency symbol.

    • Ob negative Werte durch ein führendes negatives Vorzeichen, ein nachfolgendes negatives Vorzeichen oder durch Klammern angegeben werden.Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • Ob zwischen dem numerischen Wert und dem Währungssymbol ein Leerzeichen angezeigt wird.Whether a space appears between the numeric value and the currency symbol.

  • Die CurrencyDecimalDigits -Eigenschaft, die die Anzahl der Dezimalstellen in der Ergebniszeichenfolge definiert.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • Die CurrencyDecimalSeparator -Eigenschaft, die das Dezimaltrennzeichen in der Ergebniszeichenfolge definiert.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • Die CurrencyGroupSeparator -Eigenschaft, die das Gruppentrennzeichen definiert.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • Die CurrencyGroupSizes -Eigenschaft, die die Anzahl der Stellen in jeder Gruppe links vom Dezimaltrennzeichen definiert.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • Die NegativeSign -Eigenschaft, die das negative Vorzeichen bestimmt, das in der Ergebniszeichenfolge verwendet wird, wenn negative Werte nicht mit Klammern angegeben werden.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

Darüber hinaus enthalten numerische Formatzeichenfolgen möglicherweise einen Genauigkeitsbezeichner.In addition, numeric format strings may include a precision specifier. Die Bedeutung dieses Bezeichners ist abhängig von der Formatzeichenfolge, mit der er verwendet wird. In aller Regel wird dadurch jedoch entweder die Gesamtzahl der Stellen oder die Anzahl der Dezimalstellen angegeben, die in der Ergebniszeichenfolge erscheinen soll.The meaning of this specifier depends on the format string with which it is used, but it typically indicates either the total number of digits or the number of fractional digits that should appear in the result string. So werden im folgenden Beispiel die numerische Standardzeichenfolge "X4" sowie ein Genauigkeitsbezeichner angegeben, um einen Zeichenfolgenwert mit vier Hexadezimalzahlen zu erstellen.For example, the following example uses the "X4" standard numeric string and a precision specifier to create a string value that has four hexadecimal digits.

byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
   Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
//       000C
//       00A3
//       00FF
Dim byteValues() As Byte = { 12, 163, 255 }
For Each byteValue As Byte In byteValues
   Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
'       000C
'       00A3
'       00FF

Weitere Informationen zu standardmäßigen numerischen Formatierungszeichenfolgen finden Sie unter Standard Numeric Format Strings.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Standardformatzeichenfolgen für Datums- und Uhrzeitwerte sind Aliase für benutzerdefinierte Formatzeichenfolgen, die von einer bestimmten DateTimeFormatInfo -Eigenschaft gespeichert werden.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. Beispielsweise werden durch Aufrufen der ToString-Methode eines Datums- und Uhrzeitwerts mit dem Formatbezeichner "D" das Datum und die Uhrzeit mit der benutzerdefinierten Formatzeichenfolge angezeigt, die in der DateTimeFormatInfo.LongDatePattern-Eigenschaft der aktuellen Kultur gespeichert sind.For example, calling the ToString method of a date and time value with the "D" format specifier displays the date and time by using the custom format string stored in the current culture’s DateTimeFormatInfo.LongDatePattern property. (Weitere Informationen zu benutzerdefinierten Formatzeichenfolgen finden Sie im nächsten Abschnitt.) Diese Beziehung wird anhand des folgenden Beispiels veranschaulicht.(For more information about custom format strings, see the next section.) The following example illustrates this relationship.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine("D Format Specifier:     {0:D}", date1);
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine("'{0}' custom format string:     {1}", 
                        longPattern, date1.ToString(longPattern));
   }
}
// The example displays the following output when run on a system whose
// current culture is en-US:
//    D Format Specifier:     Tuesday, June 30, 2009
//    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim date1 As Date = #6/30/2009#
      Console.WriteLine("D Format Specifier:     {0:D}", date1)
      Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
      Console.WriteLine("'{0}' custom format string:     {1}", _
                        longPattern, date1.ToString(longPattern))
   End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
'    D Format Specifier:     Tuesday, June 30, 2009
'    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Weitere Informationen zu standardmäßigen Zahlenformatzeichenfolgen finden Sie unter Standardformatzeichenfolgen für Datum und Uhrzeit.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

Sie können Standardformatzeichenfolgen auch verwenden, um die Zeichenfolgendarstellung eines anwendungsdefinierten Objekts anzugeben, die von der ToString(String) -Methode des Objekts erstellt wird.You can also use standard format strings to define the string representation of an application-defined object that is produced by the object’s ToString(String) method. Sie können die spezifischen Standardformatbezeichner definieren, die von dem Objekt unterstützt werden, und Sie können angeben, ob die Groß- und Kleinschreibung beachtet werden soll.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. Ihre Implementierung der ToString(String)-Methode sollte Folgendes unterstützen:Your implementation of the ToString(String) method should support the following:

  • Den Formatbezeichner "G", der ein übliches oder allgemeines Format des Objekts darstellt.A "G" format specifier that represents a customary or common format of the object. Die parameterlose Überladung der ToString -Methode des Objekts sollte die zugehörige ToString(String) -Überladung aufrufen und die Standardformatzeichenfolge "G" übergeben.The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Unterstützung für einen Formatbezeichner, der gleich einem NULL-Verweis (Nothing in Visual Basic) ist.Support for a format specifier that is equal to a null reference (Nothing in Visual Basic). Ein Formatbezeichner, der gleich einem NULL-Verweis ist, sollte als äquivalent mit dem "G"-Formatbezeichner angesehen werden.A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Beispielsweise kann eine Temperature-Klasse die Temperatur in Grad Celsius intern speichern und Formatbezeichner verwenden, um den Wert des Temperature-Objekts in Grad Celsius, Grad Fahrenheit und Kelvin darzustellen.For example, a Temperature class can internally store the temperature in degrees Celsius and use format specifiers to represent the value of the Temperature object in degrees Celsius, degrees Fahrenheit, and kelvins. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

using System;

public class Temperature
{
   private decimal m_Temp;
   
   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
   }

   public override string ToString()
   {
      return this.ToString("C");
   }
   
   public string ToString(string format)
   {  
      // Handle null or empty string.
      if (String.IsNullOrEmpty(format)) format = "C";
      // Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant();      
      
      // Convert temperature to Fahrenheit and return string.
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2") + " °F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2") + " K";
         // return temperature in Celsius.
         case "G":
         case "C":
            return this.Celsius.ToString("N2") + " °C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}

public class Example
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(0m);
      Console.WriteLine(temp1.ToString());
      Console.WriteLine(temp1.ToString("G"));
      Console.WriteLine(temp1.ToString("C"));
      Console.WriteLine(temp1.ToString("F"));
      Console.WriteLine(temp1.ToString("K"));

      Temperature temp2 = new Temperature(-40m);
      Console.WriteLine(temp2.ToString());
      Console.WriteLine(temp2.ToString("G"));
      Console.WriteLine(temp2.ToString("C"));
      Console.WriteLine(temp2.ToString("F"));
      Console.WriteLine(temp2.ToString("K"));

      Temperature temp3 = new Temperature(16m);
      Console.WriteLine(temp3.ToString());
      Console.WriteLine(temp3.ToString("G"));
      Console.WriteLine(temp3.ToString("C"));
      Console.WriteLine(temp3.ToString("F"));
      Console.WriteLine(temp3.ToString("K"));
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
   }
}
// The example displays the following output:
//       0.00 °C
//       0.00 °C
//       0.00 °C
//       32.00 °F
//       273.15 K
//       -40.00 °C
//       -40.00 °C
//       -40.00 °C
//       -40.00 °F
//       233.15 K
//       16.00 °C
//       16.00 °C
//       16.00 °C
//       60.80 °F
//       289.15 K
//       The temperature is now 16.00 °C.
Public Class Temperature
   Private m_Temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("C")
   End Function
   
   Public Overloads Function ToString(format As String) As String  
      ' Handle null or empty string.
      If String.IsNullOrEmpty(format) Then format = "C"
      ' Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant()      
      
      Select Case format
         Case "F"
           ' Convert temperature to Fahrenheit and return string.
            Return Me.Fahrenheit.ToString("N2") & " °F"
         Case "K"
            ' Convert temperature to Kelvin and return string.
            Return Me.Kelvin.ToString("N2") & " K"
         Case "C", "G"
            ' Return temperature in Celsius.
            Return Me.Celsius.ToString("N2") & " °C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

Public Module Example
   Public Sub Main()
      Dim temp1 As New Temperature(0d)
      Console.WriteLine(temp1.ToString())
      Console.WriteLine(temp1.ToString("G"))
      Console.WriteLine(temp1.ToString("C"))
      Console.WriteLine(temp1.ToString("F"))
      Console.WriteLine(temp1.ToString("K"))

      Dim temp2 As New Temperature(-40d)
      Console.WriteLine(temp2.ToString())
      Console.WriteLine(temp2.ToString("G"))
      Console.WriteLine(temp2.ToString("C"))
      Console.WriteLine(temp2.ToString("F"))
      Console.WriteLine(temp2.ToString("K"))

      Dim temp3 As New Temperature(16d)
      Console.WriteLine(temp3.ToString())
      Console.WriteLine(temp3.ToString("G"))
      Console.WriteLine(temp3.ToString("C"))
      Console.WriteLine(temp3.ToString("F"))
      Console.WriteLine(temp3.ToString("K"))
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
   End Sub
End Module
' The example displays the following output:
'       0.00 °C
'       0.00 °C
'       0.00 °C
'       32.00 °F
'       273.15 K
'       -40.00 °C
'       -40.00 °C
'       -40.00 °C
'       -40.00 °F
'       233.15 K
'       16.00 °C
'       16.00 °C
'       16.00 °C
'       60.80 °F
'       289.15 K
'       The temperature is now 16.00 °C.

Zurück nach obenBack to top

Benutzerdefinierte FormatzeichenfolgenCustom Format Strings

Zusätzlich zu den Standardformatzeichenfolgen definiert .NET benutzerdefinierte Formatzeichenfolgen für numerische Werte und Datums- und Uhrzeitwerte.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. Eine benutzerdefinierte Formatzeichenfolge besteht aus einem oder mehreren benutzerdefinierten Formatbezeichnern, die die Zeichenfolgendarstellung eines Werts definieren.A custom format string consists of one or more custom format specifiers that define the string representation of a value. Beispielsweise konvertiert die benutzerdefinierte Datums- und Uhrzeitformatzeichenfolge "yyyy/mm/dd hh:mm:ss.ffff t zzz" ein Datum für die Kultur en-US wie folgt in die entsprechende Zeichenfolgendarstellung: "2008/11/15 07:45:00.0000 P -08:00".For example, the custom date and time format string "yyyy/mm/dd hh:mm:ss.ffff t zzz" converts a date to its string representation in the form "2008/11/15 07:45:00.0000 P -08:00" for the en-US culture. Analog konvertiert die benutzerdefinierte Formatzeichenfolge "0000" den ganzzahligen Wert 12 in "0012".Similarly, the custom format string "0000" converts the integer value 12 to "0012". Eine vollständige Liste von benutzerdefinierten Formatzeichenfolgen finden Sie unter Custom Date and Time Format Strings und Custom Numeric Format Strings.For a complete list of custom format strings, see Custom Date and Time Format Strings and Custom Numeric Format Strings.

Wenn eine Formatzeichenfolge aus einem einzelnen benutzerdefinierten Formatbezeichner besteht, sollte dem Formatbezeichner das Prozentsymbol (%) vorangestellt werden, um Verwechslungen mit einem Standardformatbezeichner zu vermeiden.If a format string consists of a single custom format specifier, the format specifier should be preceded by the percent (%) symbol to avoid confusion with a standard format specifier. Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "M" verwendet, um eine einstellige oder zweistellige Ziffer für einen bestimmten Tag des Monats anzuzeigen.The following example uses the "M" custom format specifier to display a one-digit or two-digit number of the month of a particular date.

DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M"));       // Displays 9
Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M"))      ' Displays 9

Viele Standardformatzeichenfolgen für Datums- und Uhrzeitwerte sind Aliase für benutzerdefinierte Formatzeichenfolgen, die von Eigenschaften des DateTimeFormatInfo -Objekts definiert werden.Many standard format strings for date and time values are aliases for custom format strings that are defined by properties of the DateTimeFormatInfo object. Benutzerdefinierte Formatzeichenfolgen ermöglichen außerdem eine hohe Flexibilität beim Bereitstellen von anwendungsdefinierter Formatierung für numerische Werte oder Datums- und Uhrzeitwerte.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. Sie können eigene benutzerdefinierte Ergebniszeichenfolgen für numerische Werte und für Datums- und Uhrzeitwerte definieren, indem Sie mehrere benutzerdefinierte Formatbezeichner zu einer einzelnen benutzerdefinierten Formatzeichenfolge kombinieren.You can define your own custom result strings for both numeric values and date and time values by combining multiple custom format specifiers into a single custom format string. Im folgenden Beispiel wird eine benutzerdefinierte Formatzeichenfolge definiert, die im Anschluss an den Namen des Monats, den Tag und das Jahr den Tag der Woche in Klammern anzeigt.The following example defines a custom format string that displays the day of the week in parentheses after the month name, day, and year.

string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));   
// The example displays the following output if run on a system
// whose language is English:
//       August 28, 2009 (Friday)      
Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))   
' The example displays the following output if run on a system
' whose language is English:
'       August 28, 2009 (Friday)      

Das folgende Beispiel definiert eine benutzerdefinierte Formatzeichenfolge, die einen Int64 -Wert als standardmäßige, siebenstellige US-Telefonnummer mit der Ortskennzahl anzeigt.The following example defines a custom format string that displays an Int64 value as a standard, seven-digit U.S. telephone number along with its area code.

using System;

public class Example
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999
Module Example
   Public Sub Main()
      Dim number As Long = 8009999999
      Dim fmt As String = "000-000-0000"
      Console.WriteLine(number.ToString(fmt))
   End Sub
End Module
' The example displays the following output:

' The example displays the following output:
'       800-999-9999

Standardformatzeichenfolgen decken i. d. R. die meisten der Formatierungsanforderungen für anwendungsdefinierte Typen ab. Sie können jedoch auch benutzerdefinierte Formatbezeichner definieren, um Typen zu formatieren.Although standard format strings can generally handle most of the formatting needs for your application-defined types, you may also define custom format specifiers to format your types.

Zurück nach obenBack to top

Formatzeichenfolgen und .NET-TypenFormat Strings and .NET Types

Alle numerischen Typen (d.h. Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64 und BigInteger) sowie DateTime, DateTimeOffset, TimeSpan, Guid und alle Enumerationstypen unterstützen die Formatierung mit Formatzeichenfolgen.All numeric types (that is, the Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64, and BigInteger types), as well as the DateTime, DateTimeOffset, TimeSpan, Guid, and all enumeration types, support formatting with format strings. Informationen zu bestimmten Formatzeichenfolgen, die von jedem Typ unterstützt werden, finden Sie in den folgenden Themen:For information on the specific format strings supported by each type, see the following topics:

TitelTitle DefinitionDefinition
Standard Numeric Format StringsStandard Numeric Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von numerischen Werten erstellt werden.Describes standard format strings that create commonly used string representations of numeric values.
Custom Numeric Format StringsCustom Numeric Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für numerische Werte erstellen.Describes custom format strings that create application-specific formats for numeric values.
Standard Date and Time Format StringsStandard Date and Time Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von DateTime- undDateTimeOffset-Werten erstellt werden.Describes standard format strings that create commonly used string representations of DateTime and DateTimeOffset values.
Custom Date and Time Format StringsCustom Date and Time Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für DateTime- und DateTimeOffset-Werte erstellen.Describes custom format strings that create application-specific formats for DateTime and DateTimeOffset values.
TimeSpan-StandardformatzeichenfolgenStandard TimeSpan Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von Zeitintervallen erstellt werden.Describes standard format strings that create commonly used string representations of time intervals.
Benutzerdefinierte TimeSpan-FormatzeichenfolgenCustom TimeSpan Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für Zeitintervalle erstellen.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen Zeichenfolgenentsprechungen von Enumerationswerten erstellt werden.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Beschreibt die Standard-Formatzeichenfolgen für Guid -Werte.Describes standard format strings for Guid values.

Kulturabhängige Formatierung mit Formatanbietern und der IFormatProvider-SchnittstelleCulture-Sensitive Formatting with Format Providers and the IFormatProvider Interface

Obwohl Sie mit Formatbezeichnern die Formatierung von Objekten anpassen können, sind für eine sinnvolle Zeichenfolgendarstellung von Objekten oft zusätzliche Formatierungsinformationen erforderlich.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. Beispielsweise ist für das Formatieren einer Zahl als Währungswert mit der Standardformatzeichenfolge "C" oder mit einer benutzerdefinierten Formatzeichenfolge wie "$ #,#.00" mindestens erforderlich, dass Informationen über das richtige Währungssymbol, das richtige Gruppentrennzeichen und das richtige Dezimaltrennzeichen verfügbar sind, um in die formatierte Zeichenfolge eingeschlossen zu werden.For example, formatting a number as a currency value by using either the "C" standard format string or a custom format string such as "$ #,#.00" requires, at a minimum, information about the correct currency symbol, group separator, and decimal separator to be available to include in the formatted string. In .NET werden diese zusätzlichen Formatierungsinformationen durch die IFormatProvider-Schnittstelle verfügbar gemacht. Diese wird als Parameter für eine oder mehrere Überladungen der ToString-Methode von numerischen Typen sowie von Datums- und Uhrzeittypen bereitgestellt.In .NET, this additional formatting information is made available through the IFormatProvider interface, which is provided as a parameter to one or more overloads of the ToString method of numeric types and date and time types. IFormatProvider-Implementierungen werden in .NET verwendet, um eine kulturabhängige Formatierung zu unterstützen.IFormatProvider implementations are used in .NET to support culture-specific formatting. Im folgenden Beispiel wird veranschaulicht, wie sich die Zeichenfolgendarstellung eines Objekts ändert, wenn die Formatierung mit drei IFormatProvider -Objekten erfolgt, die verschiedene Kulturen darstellen.The following example illustrates how the string representation of an object changes when it is formatted with three IFormatProvider objects that represent different cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      decimal value = 1603.42m;
      Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
   }
}
// The example displays the following output:
//       $1,603.420
//       1 603,420 €
//       1.603,420 €
Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim value As Decimal = 1603.42d
      Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
   End Sub
End Module
' The example displays the following output:
'       $1,603.420
'       1 603,420 €
'       1.603,420 €

Die IFormatProvider -Schnittstelle enthält die GetFormat(Type)-Methode. Diese weist einen einzelnen Parameter auf, der den Typ des Objekts angibt, das Formatierungsinformationen bereitstellt.The IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Wenn die Methode ein Objekt dieses Typs bereitstellen kann, wird dieses zurückgegeben.If the method can provide an object of that type, it returns it. Andernfalls wird ein NULL-Verweis (Nothing in Visual Basic) zurückgegeben.Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormat ist eine Rückrufmethode.IFormatProvider.GetFormat is a callback method. Wenn Sie eine ToString -Methodenüberladung aufrufen, die einen IFormatProvider -Parameter einschließt, wird die GetFormat -Methode dieses IFormatProvider -Objekts aufgerufen.When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. Die GetFormat -Methode ist dafür verantwortlich, ein Objekt zurückzugeben, das die notwendigen Formatierungsinformationen, wie vom formatType -Parameter angegeben, für die ToString -Methode bereitstellt.The GetFormat method is responsible for returning an object that provides the necessary formatting information, as specified by its formatType parameter, to the ToString method.

Eine Reihe von Formatierungs- oder Zeichenfolgenkonvertierungsmethoden enthalten einen Parameter vom Typ IFormatProvider; in vielen Fällen wird der Wert des Parameters beim Aufrufen der Methode jedoch ignoriert.A number of formatting or string conversion methods include a parameter of type IFormatProvider, but in many cases the value of the parameter is ignored when the method is called. In der folgenden Tabelle sind einige Formatierungsmethoden aufgeführt, die den Parameter und den Typ des Type-Objekts verwenden, die an die IFormatProvider.GetFormat-Methode übergeben werden.The following table lists some of the formatting methods that use the parameter and the type of the Type object that they pass to the IFormatProvider.GetFormat method.

MethodeMethod formatType -ParametertypType of formatType parameter
ToString -Methode für numerische TypenToString method of numeric types System.Globalization.NumberFormatInfo
ToString-Methode für Datums- und UhrzeittypenToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Hinweis

Die ToString -Methoden der numerischen Typen und der Datums- und Uhrzeittypen werden überladen, und nur einige der Überladungen enthalten einen IFormatProvider -Parameter.The ToString methods of the numeric types and date and time types are overloaded, and only some of the overloads include an IFormatProvider parameter. Wenn eine Methode keinen Parameter vom Typ IFormatProvider aufweist, wird stattdessen das Objekt übergeben, das von der CultureInfo.CurrentCulture-Eigenschaft zurückgegeben wird.If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. Beispielsweise führt ein Aufruf der Int32.ToString()-Standardmethode letztendlich zu einem Methodenaufruf wie dem folgenden: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).For example, a call to the default Int32.ToString() method ultimately results in a method call such as the following: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

.NET stellt drei Klassen bereit, die IFormatProvider implementieren:.NET provides three classes that implement IFormatProvider:

Sie können auch einen eigenen Formatanbieter implementieren, um eine dieser Klassen zu ersetzen.You can also implement your own format provider to replace any one of these classes. Die GetFormat -Methode Ihrer Implementierung muss jedoch ein Objekt eines in der vorangehenden Tabelle aufgeführten Typs zurückgeben, um Formatierungsinformationen für die ToString -Methode bereitzustellen.However, your implementation’s GetFormat method must return an object of the type listed in the previous table if it has to provide formatting information to the ToString method.

Zurück nach obenBack to top

Kulturabhängige Formatierung von numerischen WertenCulture-Sensitive Formatting of Numeric Values

Standardmäßig ist die Formatierung von numerischen Werten kulturabhängig.By default, the formatting of numeric values is culture-sensitive. Wenn Sie beim Aufrufen einer Formatierungsmethode keine Kultur angeben, werden die Formatierungskonventionen der aktuellen Threadkultur verwendet.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Dies wird im folgenden Beispiel veranschaulicht, das die aktuelle Threadkultur viermal ändert und anschließend die Decimal.ToString(String)-Methode aufruft.This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. In allen Fällen gibt die Ergebniszeichenfolge die Formatierungskonventionen der aktuellen Kultur wieder.In each case, the result string reflects the formatting conventions of the current culture. Dies liegt daran, dass die ToString - und ToString(String) -Methoden die Aufrufe der ToString(String, IFormatProvider) -Methode jedes numerischen Typs umschließen.This is because the ToString and ToString(String) methods wrap calls to each numeric type's ToString(String, IFormatProvider) method.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      Decimal value = 1043.17m;
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(value.ToString("C2"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       $1,043.17
//       
//       The current culture is fr-FR
//       1 043,17 €
//       
//       The current culture is es-MX
//       $1,043.17
//       
//       The current culture is de-DE
//       1.043,17 €
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim value As Decimal = 1043.17d 
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(value.ToString("C2"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       $1,043.17
'       
'       The current culture is fr-FR
'       1 043,17 €
'       
'       The current culture is es-MX
'       $1,043.17
'       
'       The current culture is de-DE
'       1.043,17 €

Sie können einen numerischen Wert für eine bestimmte Kultur ebenso formatieren, indem Sie eine ToString -Überladung aufrufen, die einen provider -Parameter hat, und ihr eines der folgenden Objekte übergeben:You can also format a numeric value for a specific culture by calling a ToString overload that has a provider parameter and passing it either of the following:

  • Ein CultureInfo -Objekt, das die Kultur darstellt, deren Formatierungskonventionen verwendet werden sollen.A CultureInfo object that represents the culture whose formatting conventions are to be used. Die zugehörige CultureInfo.GetFormat-Methode gibt den Wert der CultureInfo.NumberFormat-Eigenschaft zurück, die das NumberFormatInfo-Objekt ist, das kulturspezifische Formatierungsinformationen für numerische Werte bereitstellt.Its CultureInfo.GetFormat method returns the value of the CultureInfo.NumberFormat property, which is the NumberFormatInfo object that provides culture-specific formatting information for numeric values.

  • Ein NumberFormatInfo -Objekt, das die kulturspezifischen Formatierungskonventionen definiert, die verwendet werden sollen.A NumberFormatInfo object that defines the culture-specific formatting conventions to be used. Die zugehörige GetFormat -Methode gibt eine Instanz von sich selbst zurück.Its GetFormat method returns an instance of itself.

Im folgenden Beispiel werden NumberFormatInfo -Objekte verwendet, die die Kulturen Englisch (USA) und Englisch (Großbritannien) sowie die neutralen Kulturen Französisch und Russisch darstellen, um eine Gleitkommazahl zu formatieren.The following example uses NumberFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a floating-point number.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      Double value = 1043.62957;
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 1,043.630
//       en-GB: 1,043.630
//       ru:    1 043,630
//       fr:    1 043,630
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As Double = 1043.62957
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 1,043.630
'       en-GB: 1,043.630
'       ru:    1 043,630
'       fr:    1 043,630

Kulturabhängige Formatierung von Datums- und UhrzeitwertenCulture-Sensitive Formatting of Date and Time Values

Standardmäßig ist die Formatierung von Daten- und Uhrzeitwerten kulturabhängig.By default, the formatting of date and time values is culture-sensitive. Wenn Sie beim Aufrufen einer Formatierungsmethode keine Kultur angeben, werden die Formatierungskonventionen der aktuellen Threadkultur verwendet.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Dies wird im folgenden Beispiel veranschaulicht, das die aktuelle Threadkultur viermal ändert und anschließend die DateTime.ToString(String)-Methode aufruft.This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. In allen Fällen gibt die Ergebniszeichenfolge die Formatierungskonventionen der aktuellen Kultur wieder.In each case, the result string reflects the formatting conventions of the current culture. Dies liegt daran, dass die DateTime.ToString()-, DateTime.ToString(String)-, DateTimeOffset.ToString()- und DateTimeOffset.ToString(String)-Methoden die Aufrufe der DateTime.ToString(String, IFormatProvider)- und DateTimeOffset.ToString(String, IFormatProvider)-Methoden umschließen.This is because the DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString(), and DateTimeOffset.ToString(String) methods wrap calls to the DateTime.ToString(String, IFormatProvider) and DateTimeOffset.ToString(String, IFormatProvider) methods.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(dateToFormat.ToString("F"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       Monday, May 28, 2012 11:30:00 AM
//       
//       The current culture is fr-FR
//       lundi 28 mai 2012 11:30:00
//       
//       The current culture is es-MX
//       lunes, 28 de mayo de 2012 11:30:00 a.m.
//       
//       The current culture is de-DE
//       Montag, 28. Mai 2012 11:30:00
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim dateToFormat As Date = #5/28/2012 11:30AM#
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(dateToFormat.ToString("F"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       Monday, May 28, 2012 11:30:00 AM
'       
'       The current culture is fr-FR
'       lundi 28 mai 2012 11:30:00
'       
'       The current culture is es-MX
'       lunes, 28 de mayo de 2012 11:30:00 a.m.
'       
'       The current culture is de-DE
'       Montag, 28. Mai 2012 11:30:00 

Sie können einen Datums- und Uhrzeitwert für eine bestimmte Kultur ebenso formatieren, indem Sie eine DateTime.ToString- oder DateTimeOffset.ToString-Überladung aufrufen, die einen provider-Parameter hat, und ihr eines der folgenden Objekte übergeben:You can also format a date and time value for a specific culture by calling a DateTime.ToString or DateTimeOffset.ToString overload that has a provider parameter and passing it either of the following:

Im folgenden Beispiel werden DateTimeFormatInfo -Objekte verwendet, die die Kulturen Englisch (USA) und Englisch (Großbritannien) sowie die neutralen Kulturen Französisch und Russisch darstellen, um ein Datum zu formatieren.The following example uses DateTimeFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a date.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      DateTime dat1 = new DateTime(2012, 5, 28, 11, 30, 0);
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 5/28/2012 11:30:00 AM
//       en-GB: 28/05/2012 11:30:00
//       ru: 28.05.2012 11:30:00
//       fr: 28/05/2012 11:30:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat1 As Date = #5/28/2012 11:30AM#
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 5/28/2012 11:30:00 AM
'       en-GB: 28/05/2012 11:30:00
'       ru: 28.05.2012 11:30:00
'       fr: 28/05/2012 11:30:00

IFormattable-SchnittstelleThe IFormattable Interface

Typen, die die ToString -Methode mit einer Formatzeichenfolge und einem IFormatProvider -Parameter überladen, implementieren i. d. R. auch die IFormattable -Schnittstelle.Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Diese Schnittstelle verfügt über einen einzelnen Member, IFormattable.ToString(String, IFormatProvider), der sowohl eine Formatzeichenfolge als auch einen Formatanbieter als Parameter einschließt.This interface has a single member, IFormattable.ToString(String, IFormatProvider), that includes both a format string and a format provider as parameters.

Das Implementieren der IFormattable -Schnittstelle für die anwendungsdefinierte Klasse bietet zwei Vorteile:Implementing the IFormattable interface for your application-defined class offers two advantages:

Im folgenden Beispiel wird eine Temperature -Klasse definiert, die die IFormattable -Schnittstelle implementiert.The following example defines a Temperature class that implements the IFormattable interface. Die Formatbezeichner "C" oder "G" werden darin unterstützt, um die Temperatur in Celsius anzuzeigen, der Formatbezeichner "F", um die Temperatur in Fahrenheit anzuzeigen, und der Formatbezeichner "KB", um die Temperatur in Kelvin anzuzeigen.It supports the "C" or "G" format specifiers to display the temperature in Celsius, the "F" format specifier to display the temperature in Fahrenheit, and the "K" format specifier to display the temperature in Kelvin.

using System;
using System.Globalization;

public class Temperature : IFormattable
{
   private decimal m_Temp;

   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round((decimal) this.m_Temp * 9 / 5 + 32, 2); }
   }

   public override string ToString()
   {
      return this.ToString("G", null);
   }
   
   public string ToString(string format)
   {
      return this.ToString(format, null);
   }
   
   public string ToString(string format, IFormatProvider provider)  
   {
      // Handle null or empty arguments.
      if (String.IsNullOrEmpty(format))
         format = "G";
      // Remove any white space and covert to uppercase.
      format = format.Trim().ToUpperInvariant();

      if (provider == null)
         provider = NumberFormatInfo.CurrentInfo;
            
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2", provider) + "°F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2", provider) + "K";
         // Return temperature in Celsius.
         case "C":
         case "G":
            return this.Celsius.ToString("N2", provider) + "°C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}
Imports System.Globalization

Public Class Temperature : Implements IFormattable
   Private m_Temp As Decimal

   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("G", Nothing)
   End Function
   
   Public Overloads Function ToString(format As String) As String
      Return Me.ToString(format, Nothing)
   End Function
   
   Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _  
      Implements IFormattable.ToString

      ' Handle null or empty arguments.
      If String.IsNullOrEmpty(format) Then format = "G"
      ' Remove any white space and convert to uppercase.
      format = format.Trim().ToUpperInvariant()

      If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo
            
      Select Case format
         ' Convert temperature to Fahrenheit and return string.
         Case "F"
            Return Me.Fahrenheit.ToString("N2", provider) & "°F"
         ' Convert temperature to Kelvin and return string.
         Case "K"
            Return Me.Kelvin.ToString("N2", provider) & "K"
         ' Return temperature in Celsius.
         Case "C", "G"
            Return Me.Celsius.ToString("N2", provider) & "°C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

Im folgenden Beispiel wird ein Temperature-Objekt instanziiert.The following example instantiates a Temperature object. Anschließend wird die ToString -Methode aufgerufen und mehrere zusammengesetzte Formatzeichenfolgen werden verwendet, um andere Zeichenfolgendarstellungen eines Temperature -Objekts zu erhalten.It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Die einzelnen Methoden rufen wiederum die IFormattable -Implementierung der Temperature -Klasse auf.Each of these method calls, in turn, calls the IFormattable implementation of the Temperature class.

public class Example
{
   public static void Main()
   {
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
      Temperature temp = new Temperature(22m);
      Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
      Console.WriteLine("Temperature: {0:K}", temp);
      Console.WriteLine("Temperature: {0:F}", temp);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
   }
}
// The example displays the following output:
//       22.00°C
//       Temperature: 295.15K
//       Temperature: 71.60°F
//       Temperature: 71,60°F
Public Module Example
   Public Sub Main()
      Dim temp As New Temperature(22d)
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
      Console.WriteLine(Convert.ToString(temp1, New CultureInfo("ja-JP")))
      Console.WriteLine("Temperature: {0:K}", temp)
      Console.WriteLine("Temperature: {0:F}", temp)
      Console.WriteLine(String.Format(New CultureInfo("fr-FR"), "Temperature: {0:F}", temp)) 
   End Sub
End Module
' The example displays the following output:
'       22.00°C
'       Temperature: 295.15K
'       Temperature: 71.60°F
'       Temperature: 71,60°F

Zurück nach obenBack to top

Kombinierte FormatierungComposite Formatting

Einige Methoden wie String.Format und StringBuilder.AppendFormat unterstützen die kombinierte Formatierung.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. Eine kombinierte Formatzeichenfolge ist eine Vorlage, die verwendet wird, um eine einzelne Zeichenfolge zurückzugeben, die die Zeichenfolgendarstellung von 0 (null), einem oder mehreren Objekten beinhaltet.A composite format string is a kind of template that returns a single string that incorporates the string representation of zero, one, or more objects. Jedes Objekt wird in der kombinierten Formatzeichenfolge durch ein indiziertes Formatelement dargestellt.Each object is represented in the composite format string by an indexed format item. Der Index des Formatelements entspricht der Position des Objekts, das es in der Parameterliste der Methode darstellt.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Indizes sind nullbasiert.Indexes are zero-based. Beispielsweise wird im folgenden Aufruf der String.Format-Methode das erste Formatelement {0:D} durch die Zeichenfolgendarstellung von thatDate ersetzt. Das zweite Formatelement {1} wird durch die Zeichenfolgendarstellung item1 ersetzt, und das dritte Formatelement {2:C2} wird durch die Zeichenfolgendarstellung von item1.Value ersetzt.For example, in the following call to the String.Format method, the first format item, {0:D}, is replaced by the string representation of thatDate; the second format item, {1}, is replaced by the string representation of item1; and the third format item, {2:C2}, is replaced by the string representation of item1.Value.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", 
                       thatDate, item1, item1.Value);
Console.WriteLine(result);                            
// The example displays output like the following if run on a system
// whose current culture is en-US:
//       On 5/1/2009, the inventory of WidgetA was worth $107.44.
result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", _
                       thatDate, item1, item1.Value)
Console.WriteLine(result)                            
' The example displays output like the following if run on a system
' whose current culture is en-US:
'       On 5/1/2009, the inventory of WidgetA was worth $107.44.

Zusätzlich zum Ersetzen eines Formatelements durch die Zeichenfolgendarstellung seines entsprechenden Objekts können Sie mit Formatelementen auch Folgendes steuern:In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • Die spezifische Art, in der ein Objekt als Zeichenfolge dargestellt wird, wenn das Objekt die IFormattable -Schnittstelle implementiert und Formatzeichenfolgen unterstützt.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. Zu diesem Zweck geben Sie nach dem Index des Formatelements einen : (Doppelpunkt) ein, gefolgt von einer gültigen Formatzeichenfolge.You do this by following the format item's index with a : (colon) followed by a valid format string. Im vorherigen Beispiel wurde hierzu ein Datumswert mit der Formatzeichenfolge "d" (kurzes Datumsmuster) formatiert (z. B. {0:d}) und ein numerischer Wert mit der Formatzeichenfolge "C2" formatiert (z. B. {2:C2} ), um die Zahl als Währungswert mit zwei Dezimalstellen für Sekundenbruchteile darzustellen.The previous example did this by formatting a date value with the "d" (short date pattern) format string (e.g., {0:d}) and by formatting a numeric value with the "C2" format string (e.g., {2:C2} to represent the number as a currency value with two fractional decimal digits.

  • Die Breite des Felds, das die Zeichenfolgendarstellung des Objekts enthält, und die Ausrichtung der Zeichenfolgendarstellung in diesem Feld.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. Hierzu geben Sie nach dem Index des Formatelements ein , (Komma) ein, gefolgt von der Feldbreite.You do this by following the format item's index with a , (comma) followed the field width. Die Zeichenfolge wird rechtsbündig in dem Feld ausgerichtet, wenn die Feldbreite ein positiver Wert ist, und linksbündig, wenn die Feldbreite ein negativer Wert ist.The string is right-aligned in the field if the field width is a positive value, and it is left-aligned if the field width is a negative value. Im folgenden Beispiel werden Datumswerte in einem 20 Zeichen breiten Feld linksbündig ausgerichtet, und Dezimalwerte mit einer Hinterkommastelle werden in einem 11 Zeichen breiten Feld rechtsbündig ausgerichtet.The following example left-aligns date values in a 20-character field, and it right-aligns decimal values with one fractional digit in an 11-character field.

    DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0);
    decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m,
                       74.1m, 72.156m, 72.228m };
    Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature");
    for (int ctr = 0; ctr < temps.Length; ctr++)
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]);
    
    // The example displays the following output:
    //       Date                 Temperature
    //
    //       8/28/2015 6:00 AM           73.5
    //       8/29/2015 6:00 AM           69.0
    //       8/30/2015 6:00 AM           72.6
    //       8/31/2015 6:00 AM           69.2
    //       9/1/2015 6:00 AM            74.1
    //       9/2/2015 6:00 AM            72.2
    //       9/3/2015 6:00 AM            72.2
    
    Dim startDate As New Date(2015, 8, 28, 6, 0, 0)
    Dim temps() As Decimal = { 73.452, 68.98, 72.6, 69.24563,
                               74.1, 72.156, 72.228 }
    Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature")
    Console.WriteLine()
    For ctr As Integer = 0 To temps.Length - 1
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr))
    Next
    ' The example displays the following output:
    '       Date                 Temperature
    '
    '       8/28/2015 6:00 AM           73.5
    '       8/29/2015 6:00 AM           69.0
    '       8/30/2015 6:00 AM           72.6
    '       8/31/2015 6:00 AM           69.2
    '       9/1/2015 6:00 AM            74.1
    '       9/2/2015 6:00 AM            72.2
    '       9/3/2015 6:00 AM            72.2
    

    Beachten Sie, dass, wenn sowohl die Ausrichtungszeichenfolge-Komponente als auch die Formatzeichenfolgen-Komponente vorhanden ist, die erste der letzteren vorausgeht (z. B. {0,-20:g}).Note that, if both the alignment string component and the format string component are present, the former precedes the latter (for example, {0,-20:g}.

Weitere Informationen zur zusammengesetzten Formatierung finden Sie unter Composite Formatting.For more information about composite formatting, see Composite Formatting.

Zurück nach obenBack to top

Benutzerdefinierte Formatierung mit ICustomFormatterCustom Formatting with ICustomFormatter

Zwei Methoden zur kombinierten Formatierung, String.Format(IFormatProvider, String, Object[]) und StringBuilder.AppendFormat(IFormatProvider, String, Object[]), enthalten auch einen Formatanbieterparameter, der die benutzerdefinierte Formatierung unterstützt.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Wenn eine der beiden Formatierungsmethoden aufgerufen wird, übergibt sie ein Type -Objekt, das eine ICustomFormatter -Schnittstelle für die GetFormat -Methode des Formatanbieters darstellt.When either of these formatting methods is called, it passes a Type object that represents an ICustomFormatter interface to the format provider’s GetFormat method. Die GetFormat -Methode ist dann dafür verantwortlich, die ICustomFormatter -Implementierung zurückzugeben, die die benutzerdefinierte Formatierung bereitstellt.The GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

Die ICustomFormatter -Schnittstelle verfügt über eine einzelne Methode, Format(String, Object, IFormatProvider), die für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge automatisch von einer kombinierten Formatierungsmethode aufgerufen wird.The ICustomFormatter interface has a single method, Format(String, Object, IFormatProvider), that is called automatically by a composite formatting method, once for each format item in a composite format string. Die Format(String, Object, IFormatProvider) -Methode verfügt über drei Parameter: eine Formatzeichenfolge, die das formatString -Argument in einem Formatelement darstellt, ein Objekt zum Formatieren und ein IFormatProvider -Objekt, das Formatierungsdienste bereitstellt.The Format(String, Object, IFormatProvider) method has three parameters: a format string, which represents the formatString argument in a format item, an object to format, and an IFormatProvider object that provides formatting services. In der Regel implementiert die Klasse, die ICustomFormatter implementiert, auch IFormatProvider; der letzte Parameter stellt daher einen Verweis auf die benutzerdefinierte Formatierungsklasse selbst dar.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. Die Methode gibt eine benutzerdefinierte formatierte Zeichenfolgendarstellung des Objekts zurück, das formatiert werden soll.The method returns a custom formatted string representation of the object to be formatted. Wenn die Methode das Objekt nicht formatieren kann, sollte ein NULL-Verweis (Nothing in Visual Basic) zurückgegeben werden.If the method cannot format the object, it should return a null reference (Nothing in Visual Basic).

Im folgenden Beispiel wird eine ICustomFormatter -Implementierung mit dem Namen ByteByByteFormatter bereitgestellt, die ganzzahlige Werte als Sequenz von zweistelligen Hexadezimalwerten, gefolgt von einem Leerzeichen anzeigt.The following example provides an ICustomFormatter implementation named ByteByByteFormatter that displays integer values as a sequence of two-digit hexadecimal values followed by a space.

public class ByteByByteFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(string format, object arg, 
                          IFormatProvider formatProvider)
   {   
      if (! formatProvider.Equals(this)) return null;
      
      // Handle only hexadecimal format string.
      if (! format.StartsWith("X")) return null;
      
      byte[] bytes;
      string output = null;
      
      // Handle only integral types.
      if (arg is Byte) 
         bytes = BitConverter.GetBytes((Byte) arg);
      else if (arg is Int16)
         bytes = BitConverter.GetBytes((Int16) arg);
      else if (arg is Int32)
         bytes = BitConverter.GetBytes((Int32) arg);
      else if (arg is Int64)   
         bytes = BitConverter.GetBytes((Int64) arg);
      else if (arg is SByte)
         bytes = BitConverter.GetBytes((SByte) arg);
      else if (arg is UInt16)
         bytes = BitConverter.GetBytes((UInt16) arg);
      else if (arg is UInt32)
         bytes = BitConverter.GetBytes((UInt32) arg);
      else if (arg is UInt64)
         bytes = BitConverter.GetBytes((UInt64) arg);
      else
         return null;

      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         output += String.Format("{0:X2} ", bytes[ctr]);   
      
      return output.Trim();
   }
}
Public Class ByteByByteFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                          Implements ICustomFormatter.Format

      If Not formatProvider.Equals(Me) Then Return Nothing

      ' Handle only hexadecimal format string.
      If Not fmt.StartsWith("X") Then 
            Return Nothing
      End If

      ' Handle only integral types.
      If Not typeof arg Is Byte AndAlso
         Not typeof arg Is Int16 AndAlso
         Not typeof arg Is Int32 AndAlso
         Not typeof arg Is Int64 AndAlso
         Not typeof arg Is SByte AndAlso
         Not typeof arg Is UInt16 AndAlso
         Not typeof arg Is UInt32 AndAlso
         Not typeof arg Is UInt64 Then _
            Return Nothing

      Dim bytes() As Byte = BitConverter.GetBytes(arg)
      Dim output As String = Nothing
         
      For ctr As Integer = bytes.Length - 1 To 0 Step -1
         output += String.Format("{0:X2} ", bytes(ctr))   
      Next
      
      Return output.Trim()
   End Function
End Class

Im folgenden Beispiel werden mit der ByteByByteFormatter -Klasse Ganzzahlwerte formatiert.The following example uses the ByteByByteFormatter class to format integer values. Beachten Sie, dass die ICustomFormatter.Format-Methode im zweiten Aufruf der String.Format(IFormatProvider, String, Object[])-Methode mehr als einmal aufgerufen wird, und dass der NumberFormatInfo-Standardanbieter im dritten Methodenaufruf verwendet wird, da die ByteByByteFormatter.FormatNote that the ICustomFormatter.Format method is called more than once in the second String.Format(IFormatProvider, String, Object[]) method call, and that the default NumberFormatInfo provider is used in the third method call because the .ByteByByteFormatter.Format -Methode die Formatzeichenfolge "N0" nicht erkennt und ein NULL-Verweis (Nothing in Visual Basic) ist.method does not recognize the "N0" format string and returns a null reference (Nothing in Visual Basic).

public class Example
{
   public static void Main()
   {
      long value = 3210662321; 
      byte value1 = 214;
      byte value2 = 19;
      
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 & value2));                                
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
   }
}
// The example displays the following output:
//       00 00 00 00 BF 5E D1 B1
//       00 D6 And 00 13 = 00 12 (018)
//       3,210,662,321
Public Module Example
   Public Sub Main()
      Dim value As Long = 3210662321 
      Dim value1 As Byte = 214
      Dim value2 As Byte = 19
      
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 And value2)))                                
      Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
   End Sub
End Module
' The example displays the following output:
'       00 00 00 00 BF 5E D1 B1
'       00 D6 And 00 13 = 00 12 (018)
'       3,210,662,321

Zurück nach obenBack to top

TitelTitle DefinitionDefinition
Standard Numeric Format StringsStandard Numeric Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von numerischen Werten erstellt werden.Describes standard format strings that create commonly used string representations of numeric values.
Custom Numeric Format StringsCustom Numeric Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für numerische Werte erstellen.Describes custom format strings that create application-specific formats for numeric values.
Standard Date and Time Format StringsStandard Date and Time Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von DateTime -Werten erstellt werden.Describes standard format strings that create commonly used string representations of DateTime values.
Custom Date and Time Format StringsCustom Date and Time Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für DateTime -Werte erstellen.Describes custom format strings that create application-specific formats for DateTime values.
TimeSpan-StandardformatzeichenfolgenStandard TimeSpan Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen häufig verwendete Zeichenfolgenentsprechungen von Zeitintervallen erstellt werden.Describes standard format strings that create commonly used string representations of time intervals.
Benutzerdefinierte TimeSpan-FormatzeichenfolgenCustom TimeSpan Format Strings Beschreibt benutzerdefinierte Formatzeichenfolgen, die anwendungsspezifische Formate für Zeitintervalle erstellen.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Beschreibt als Standard verwendete Formatzeichenfolgen, mit denen Zeichenfolgenentsprechungen von Enumerationswerten erstellt werden.Describes standard format strings that are used to create string representations of enumeration values.
Kombinierte FormatierungComposite Formatting Beschreibt die Einbettung eines oder mehrerer formatierter Werte in eine Zeichenfolge.Describes how to embed one or more formatted values in a string. Die Zeichenfolge kann anschließend in der Konsole angezeigt oder in einen Stream geschrieben werden.The string can subsequently be displayed on the console or written to a stream.
Durchführen von FormatierungsvorgängenPerforming Formatting Operations Enthält Themen, in denen schrittweise Anleitungen zum Ausführen bestimmter Formatierungsvorgänge vorgestellt werden.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Parsing StringsParsing Strings Beschreibt, wie Objekte mit den Werten initialisiert werden, die durch Zeichenfolgenentsprechungen dieser Objekte beschrieben werden.Describes how to initialize objects to the values described by string representations of those objects. Das Verarbeiten ist die Umkehroperation zum Formatieren.Parsing is the inverse operation of formatting.

Zurück nach obenBack to top

VerweisReference

System.IFormattable

System.IFormatProvider

System.ICustomFormatter