Kombinierte FormatierungComposite Formatting

Die Funktion für die kombinierte Formatierung in .NET verwendet als Eingabe eine Liste von Objekten und eine kombinierte Formatzeichenfolge.The .NET composite formatting feature takes a list of objects and a composite format string as input. Eine kombinierte Formatzeichenfolge besteht aus festgelegtem Text mit indizierten Platzhaltern, so genannten Formatelementen, die den Objekten in der Liste entsprechen.A composite format string consists of fixed text intermixed with indexed placeholders, called format items, that correspond to the objects in the list. Der Formatierungsvorgang liefert eine Ergebniszeichenfolge, die sich aus dem ursprünglichen festgelegten Text und der Zeichenfolgendarstellung der Objekte in der Liste zusammensetzt.The formatting operation yields a result string that consists of the original fixed text intermixed with the string representation of the objects in the list.

Wichtig

Anstelle kombinierter Formatzeichenfolgen können Sie interpolierte Zeichenfolgen verwenden, wenn die von Ihnen verwendete Sprache und Sprachversion diese unterstützen.Instead of using composite format strings, you can use interpolated strings if the language and language version that you're using support them. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält.An interpolated string is a string that contains interpolated expressions. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).For more information, see String interpolation (C# Reference) and Interpolated strings (Visual Basic Reference).

Die Funktion für kombinierte Formatierung wird beispielsweise von folgenden Methoden unterstützt:The composite formatting feature is supported by methods such as the following:

Kombinierte FormatzeichenfolgeComposite Format String

Eine kombinierte Formatzeichenfolge und eine Objektliste dienen als Argumente von Methoden, die das Feature für die kombinierte Formatierung unterstützen.A composite format string and object list are used as arguments of methods that support the composite formatting feature. Die Quellzeichenfolge besteht aus 0 (null) oder mehreren Einheiten festgelegten Texts mit mindestens einem Formatelement.A composite format string consists of zero or more runs of fixed text intermixed with one or more format items. Der festgelegte Text ist eine von Ihnen ausgewählte beliebige Zeichenfolge. Jedes Formatelement entspricht einem Objekt oder einer geschachtelten Struktur in der Liste.The fixed text is any string that you choose, and each format item corresponds to an object or boxed structure in the list. Die Funktion für die kombinierte Formatierung gibt eine neue Ergebniszeichenfolge zurück, in der jedes Formatelement durch die Zeichenfolgendarstellung des entsprechenden Objekts in der Liste ersetzt wird.The composite formatting feature returns a new result string where each format item is replaced by the string representation of the corresponding object in the list.

Betrachten Sie das folgende Format-Codefragment:Consider the following Format code fragment.

string name = "Fred";
String.Format("Name = {0}, hours = {1:hh}", name, DateTime.Now);
Dim name As String = "Fred"
String.Format("Name = {0}, hours = {1:hh}", name, DateTime.Now)

Der feste Text ist „Name =“ und „, hours =“.The fixed text is "Name = " and ", hours = ". Die Formatelemente sind „{0}“ mit dem Index 0, was dem Objekt name entspricht, und „{1:hh}“ mit dem Index 1, was dem Objekt DateTime.Now entspricht.The format items are "{0}", whose index is 0, which corresponds to the object name, and "{1:hh}", whose index is 1, which corresponds to the object DateTime.Now.

FormatelementsyntaxFormat Item Syntax

Alle Formatelemente weisen die folgende Form auf und bestehen aus folgenden Komponenten:Each format item takes the following form and consists of the following components:

{ Index[,Ausrichtung][:Formatzeichenfolge]}{ index[,alignment][:formatString]}

Die übereinstimmenden geschweiften Klammern ("{" and "}") sind erforderlich.The matching braces ("{" and "}") are required.

IndexkomponenteIndex Component

Bei der obligatorischen Komponente Index, dem so genannten Parameterbezeichner, handelt es sich um eine bei 0 (null) beginnende Zahl, mit der ein entsprechendes Element in der Objektliste angegeben wird.The mandatory index component, also called a parameter specifier, is a number starting from 0 that identifies a corresponding item in the list of objects. Das bedeutet, dass das Formatelement mit dem Parameterbezeichner 0 (null) das erste Objekt in der Liste formatiert, und das Formatelement mit dem Parameterbezeichner 1 formatiert das zweite Objekt in der Liste usw.That is, the format item whose parameter specifier is 0 formats the first object in the list, the format item whose parameter specifier is 1 formats the second object in the list, and so on. Das folgende Beispiel enthält vier von null bis drei nummerierte Parameterbezeichner zur Darstellung von Primzahlen, die kleiner als zehn sind:The following example includes four parameter specifiers, numbered zero through three, to represent prime numbers less than ten:

string primes;
primes = String.Format("Prime numbers less than 10: {0}, {1}, {2}, {3}",
                       2, 3, 5, 7 );
Console.WriteLine(primes);
// The example displays the following output:
//      Prime numbers less than 10: 2, 3, 5, 7
Dim primes As String
primes = String.Format("Prime numbers less than 10: {0}, {1}, {2}, {3}",
                       2, 3, 5, 7 )
Console.WriteLine(primes)
' The example displays the following output:
'      Prime numbers less than 10: 2, 3, 5, 7

Mehrere Formatelemente können auf dasselbe Element in der Objektliste verweisen, indem derselbe Parameterbezeichner festgelegt wird.Multiple format items can refer to the same element in the list of objects by specifying the same parameter specifier. Sie können beispielsweise denselben numerischen Wert im hexadezimalen, im wissenschaftlichen und im Zahlenformat formatieren, indem Sie eine kombinierte Formatzeichenfolge wie die Folgende angeben: "0x{0:X} {0:E} {0:N}" wie im folgenden Beispiel gezeigt.For example, you can format the same numeric value in hexadecimal, scientific, and number format by specifying a composite format string such as : "0x{0:X} {0:E} {0:N}", as the following example shows.

string multiple = String.Format("0x{0:X} {0:E} {0:N}",
                                Int64.MaxValue);
Console.WriteLine(multiple);
// The example displays the following output:
//      0x7FFFFFFFFFFFFFFF 9.223372E+018 9,223,372,036,854,775,807.00
Dim multiple As String = String.Format("0x{0:X} {0:E} {0:N}",
                                       Int64.MaxValue)
Console.WriteLine(multiple)
' The example displays the following output:
'      0x7FFFFFFFFFFFFFFF 9.223372E+018 9,223,372,036,854,775,807.00

Jedes Formatelement kann auf ein beliebiges Objekt in der Liste verweisen.Each format item can refer to any object in the list. Wenn beispielsweise drei Objekte vorliegen, können Sie das zweite, erste und dritte Objekt formatieren, indem Sie eine kombinierte Formatzeichenfolge wie die folgende angeben: „{1} {0} {2}“.For example, if there are three objects, you can format the second, first, and third object by specifying a composite format string like this: "{1} {0} {2}". Ein Objekt, auf das kein Formatelement verweist, wird ignoriert.An object that is not referenced by a format item is ignored. Eine FormatException wird zur Laufzeit ausgelöst, wenn ein Parameterbezeichner auf ein Element außerhalb der Grenzen der Objektliste verweist.A FormatException is thrown at runtime if a parameter specifier designates an item outside the bounds of the list of objects.

AusrichtungskomponenteAlignment Component

Bei der optionalen Komponente Ausrichtung handelt es sich um eine ganze Zahl mit Vorzeichen, die die gewünschte formatierte Feldbreite angibt.The optional alignment component is a signed integer indicating the preferred formatted field width. Wenn der Wert für Ausrichtung kleiner als die Länge der formatierten Zeichenfolge ist, wird Ausrichtung ignoriert, und die Länge der formatierten Zeichenfolge wird als Feldbreite verwendet.If the value of alignment is less than the length of the formatted string, alignment is ignored and the length of the formatted string is used as the field width. Die formatierten Daten im Feld werden bei einem positiven Wert für Ausrichtung rechtsbündig und bei einem negativen Wert für Ausrichtung linksbündig ausgerichtet.The formatted data in the field is right-aligned if alignment is positive and left-aligned if alignment is negative. Wenn Füllzeichen erforderlich sind, werden Leerräume verwendet.If padding is necessary, white space is used. Das Komma ist erforderlich, wenn Ausrichtung angegeben wird.The comma is required if alignment is specified.

Im folgenden Beispiel werden zwei Arrays definiert, ein Array mit den Namen der Mitarbeiter und ein Array mit den Arbeitsstunden der Mitarbeiter über einen Zeitraum von zwei Wochen.The following example defines two arrays, one containing the names of employees and the other containing the hours they worked over a two-week period. Die kombinierte Formatzeichenfolge richtet die Namen in einem Feld mit 20 Zeichen linksbündig aus, und die Stunden werden in einem Feld mit 5 Zeichen rechtsbündig ausgerichtet.The composite format string left-aligns the names in a 20-character field, and right-aligns their hours in a 5-character field. Beachten Sie, dass auch die Standardformatzeichenfolge "N1" verwendet wird, um die Stunden mit einer Dezimalstelle zu formatieren.Note that the "N1" standard format string is also used to format the hours with one fractional digit.

using System;

public class Example
{
   public static void Main()
   {
      string[] names = { "Adam", "Bridgette", "Carla", "Daniel",
                         "Ebenezer", "Francine", "George" };
      decimal[] hours = { 40, 6.667m, 40.39m, 82, 40.333m, 80,
                                 16.75m };

      Console.WriteLine("{0,-20} {1,5}\n", "Name", "Hours");
      for (int ctr = 0; ctr < names.Length; ctr++)
         Console.WriteLine("{0,-20} {1,5:N1}", names[ctr], hours[ctr]);

   }
}
// The example displays the following output:
//       Name                 Hours
//
//       Adam                  40.0
//       Bridgette              6.7
//       Carla                 40.4
//       Daniel                82.0
//       Ebenezer              40.3
//       Francine              80.0
//       George                16.8
Module Example
   Public Sub Main()
      Dim names() As String = { "Adam", "Bridgette", "Carla", "Daniel",
                                "Ebenezer", "Francine", "George" }
      Dim hours() As Decimal = { 40, 6.667d, 40.39d, 82, 40.333d, 80,
                                 16.75d }

      Console.WriteLine("{0,-20} {1,5}", "Name", "Hours")
      Console.WriteLine()
      For ctr As Integer = 0 To names.Length - 1
         Console.WriteLine("{0,-20} {1,5:N1}", names(ctr), hours(ctr))
      Next
   End Sub
End Module
' The example displays the following output:
'       Name                 Hours
'
'       Adam                  40.0
'       Bridgette              6.7
'       Carla                 40.4
'       Daniel                82.0
'       Ebenezer              40.3
'       Francine              80.0
'       George                16.8

Formatzeichenfolgen-KomponenteFormat String Component

Die optionale Komponente Formatzeichenfolge ist eine Formatzeichenfolge, die für den formatierten Objekttyp geeignet ist.The optional formatString component is a format string that is appropriate for the type of object being formatted. Geben Sie eine standardmäßige oder eine benutzerdefinierte numerische Formatzeichenfolge an, wenn das entsprechende Objekt ein numerischer Wert ist. Geben Sie eine standardmäßige oder eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit an, wenn das entsprechende Objekt ein DateTime-Objekt ist. Geben Sie eine Enumerationsformatzeichenfolge an, wenn das entsprechende Objekt ein Enumerationswert ist.Specify a standard or custom numeric format string if the corresponding object is a numeric value, a standard or custom date and time format string if the corresponding object is a DateTime object, or an enumeration format string if the corresponding object is an enumeration value. Wenn Formatzeichenfolge nicht festgelegt ist, wird der allgemeine Formatbezeichner („G“) für einen numerischen, Datums- und Uhrzeit- oder Enumerationstyp verwendet.If formatString is not specified, the general ("G") format specifier for a numeric, date and time, or enumeration type is used. Der Doppelpunkt ist erforderlich, wenn Formatzeichenfolge angegeben wird.The colon is required if formatString is specified.

Die folgende Tabelle listet Typen oder Kategorien von Typen in der .NET Framework-Klassenbibliothek auf, die einen vordefinierten Satz von Formatzeichenfolgen unterstützen, und stellt Links zu Themen bereit, die die unterstützten Formatzeichenfolgen auflisten.The following table lists types or categories of types in the .NET Framework class library that support a predefined set of format strings, and provides links to the topics that list the supported format strings. Beachten Sie, dass die Zeichenfolgenformatierung ein erweiterbarer Mechanismus ist, der es ermöglicht, neue Formatzeichenfolgen für alle vorhandenen Typen zu definieren und einen Satz von Formatzeichenfolgen zu definieren, der von einem anwendungsdefinierten Typ unterstützt wird.Note that string formatting is an extensible mechanism that makes it possible to define new format strings for all existing types as well as to define a set of format strings supported by an application-defined type. Weitere Informationen finden Sie unter den Themen zur IFormattable-Schnittstelle und ICustomFormatter-Schnittstelle.For more information, see the IFormattable and ICustomFormatter interface topics.

Typ oder TypkategorieType or type category SieheSee
Datums-/Zeittypen (DateTime, DateTimeOffset)Date and time types (DateTime, DateTimeOffset) Standard Date and Time Format StringsStandard Date and Time Format Strings

Custom Date and Time Format StringsCustom Date and Time Format Strings
Enumerationstypen (alle Typen abgeleitet von System.Enum)Enumeration types (all types derived from System.Enum) Enumeration Format StringsEnumeration Format Strings
Numerische Typen (BigInteger, Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64)Numeric types (BigInteger, Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64) Standard Numeric Format StringsStandard Numeric Format Strings

Custom Numeric Format StringsCustom Numeric Format Strings
Guid Guid.ToString(String)
TimeSpan TimeSpan-StandardformatzeichenfolgenStandard TimeSpan Format Strings

Benutzerdefinierte TimeSpan-FormatzeichenfolgenCustom TimeSpan Format Strings

Versehen von geschweiften Klammern mit EscapezeichenEscaping Braces

Öffnende und schließende geschweifte Klammern werden als Beginn und Ende eines Formatelements interpretiert.Opening and closing braces are interpreted as starting and ending a format item. Deshalb müssen Sie eine Escapesequenz verwenden, um eine literale öffnende bzw. schließende geschweifte Klammer anzuzeigen.Consequently, you must use an escape sequence to display a literal opening brace or closing brace. Geben Sie zwei öffnende geschweifte Klammern ("{{") im festgelegten Text an, um eine öffnende geschweifte Klammer ("{") anzuzeigen, und geben Sie entsprechend zwei schließende geschweifte Klammern ("}}") an, um eine schließende geschweifte Klammer ("}") anzuzeigen.Specify two opening braces ("{{") in the fixed text to display one opening brace ("{"), or two closing braces ("}}") to display one closing brace ("}"). Geschweifte Klammern in einem Formatelement werden sequenziell in der Reihenfolge interpretiert, in der sie angetroffen werden.Braces in a format item are interpreted sequentially in the order they are encountered. Die Interpretation geschachtelter geschweifter Klammern wird nicht unterstützt.Interpreting nested braces is not supported.

Die Art und Weise, wie geschweifte Klammern mit Escapezeichen interpretiert werden, kann zu unerwarteten Ergebnissen führen.The way escaped braces are interpreted can lead to unexpected results. Betrachten Sie beispielsweise das Formatelement „{{{0:D}}}“, das eine öffnende geschweifte Klammer anzeigen soll, einen numerischen Wert, der als Dezimalzahl formatiert ist, und eine schließende geschweifte Klammer.For example, consider the format item "{{{0:D}}}", which is intended to display an opening brace, a numeric value formatted as a decimal number, and a closing brace. Das Formatelement wird aber tatsächlich wie folgt interpretiert:However, the format item is actually interpreted in the following manner:

  1. Die ersten beiden öffnenden geschweiften Klammern ("{{") werden mit Escapezeichen versehen und ergeben eine öffnende geschweifte Klammer.The first two opening braces ("{{") are escaped and yield one opening brace.

  2. Die nächsten drei Zeichen ("{0":) werden als Anfang eines Formatelements interpretiert.The next three characters ("{0:") are interpreted as the start of a format item.

  3. Das nächste Zeichen ("D") wird als Formatbezeichner für das numerische Standarddezimalformat interpretiert, und die nächsten beiden geschweiften Klammern mit Escapezeichen ergeben eine einzelne geschweifte Klammer.The next character ("D") would be interpreted as the Decimal standard numeric format specifier, but the next two escaped braces ("}}") yield a single brace. Da die entstehende Zeichenfolge ("D}") kein numerischer Standardformatbezeichner ist, wird sie als benutzerdefinierte Formatzeichenfolge interpretiert, d. h., es wird die Literalzeichenfolge "D}" angezeigt.Because the resulting string ("D}") is not a standard numeric format specifier, the resulting string is interpreted as a custom format string that means display the literal string "D}".

  4. Die letzte geschweifte Klammer ("}") wird als Ende des Formatelements interpretiert.The last brace ("}") is interpreted as the end of the format item.

  5. Das Endergebnis, das angezeigt wird, ist die Literalzeichenfolge "{D}".The final result that is displayed is the literal string, "{D}". Der numerische Wert, der formatiert werden sollte, wird nicht angezeigt.The numeric value that was to be formatted is not displayed.

Eine Möglichkeit, Code zu schreiben und dabei Probleme mit falsch interpretierten geschweiften Klammern und Formatelementen zu vermeiden, ist die separate Formatierung der geschweiften Klammern und Formatelemente.One way to write your code to avoid misinterpreting escaped braces and format items is to format the braces and format item separately. Zeigen Sie also beim ersten Formatierungsvorgang eine literale öffnende geschweifte Klammer, beim nächsten Formatierungsvorgang das Ergebnis des Formatelements und beim letzten Formatierungsvorgang eine literale schließende geschweifte Klammer an.That is, in the first format operation display a literal opening brace, in the next operation display the result of the format item, then in the final operation display a literal closing brace. Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this approach.

int value = 6324;
string output = string.Format("{0}{1:D}{2}", 
                             "{", value, "}");
Console.WriteLine(output);
// The example displays the following output:
//       {6324}                            
Dim value As Integer = 6324
Dim output As String = String.Format("{0}{1:D}{2}", _
                                     "{", value, "}")
Console.WriteLine(output)   
' The example displays the following output:
'       {6324}

VerarbeitungsreihenfolgeProcessing Order

Wenn der Aufruf der Methode für die kombinierte Formatierung ein IFormatProvider-Argument enthält, dessen Wert nicht null ist, ruft die Laufzeit die IFormatProvider.GetFormat-Methode auf, um eine ICustomFormatter-Implementierung anzufordern.If the call to the composite formatting method includes an IFormatProvider argument whose value is not null, the runtime calls its IFormatProvider.GetFormat method to request an ICustomFormatter implementation. Wenn die Methode eine ICustomFormatter-Implementierung zurückgeben kann, wird diese während des gesamten Aufrufs der Methode zur kombinierten Formatierung zwischengespeichert.If the method is able to return an ICustomFormatter implementation, it's cached for the duration of the call of the composite formatting method.

Jeder Wert in der Parameterliste, der einem Formatelement entspricht, wird wie folgt in eine Zeichenfolge konvertiert:Each value in the parameter list that corresponds to a format item is converted to a string as follows:

  1. Wenn der zu formatierende Wert null ist, wird eine leere Zeichenfolge (String.Empty) zurückgegeben.If the value to be formatted is null, an empty string String.Empty is returned.

  2. Wenn eine ICustomFormatter-Implementierung verfügbar ist, ruft die Laufzeit die Format-Methode auf.If an ICustomFormatter implementation is available, the runtime calls its Format method. Sie übergibt den formatString-Wert des Formatelements, sofern vorhanden, oder andernfalls null zusammen mit der IFormatProvider-Implementierung an die Methode.It passes the method the format item's formatString value, if one is present, or null if it's not, along with the IFormatProvider implementation. Wenn durch den Aufruf der ICustomFormatter.Format-Methode null zurückgegeben wird, wird der nächste Schritt ausgeführt. Andernfalls wird das Ergebnis des ICustomFormatter.Format-Aufrufs zurückgegeben.If the call to the ICustomFormatter.Format method returns null, execution proceeds to the next step; otherwise, the result of the ICustomFormatter.Format call is returned.

  3. Wenn der Wert die IFormattable-Schnittstelle implementiert, wird die ToString(String, IFormatProvider)-Methode der Schnittstelle aufgerufen.If the value implements the IFormattable interface, the interface's ToString(String, IFormatProvider) method is called. Der Formatzeichenfolge-Wert wird, sofern im Formatelement vorhanden, an die Methode übergeben. Ist dies nicht der Fall, wird null übergeben.The method is passed the formatString value, if one is present in the format item, or null if it's not. Das IFormatProvider-Argument wird wie folgt bestimmt:The IFormatProvider argument is determined as follows:

  4. Die parameterlose ToString-Methode des Typs, die entweder Object.ToString() überschreibt oder das Verhalten ihrer Basisklasse erbt, wird aufgerufen.The type's parameterless ToString method, which either overrides Object.ToString() or inherits the behavior of its base class, is called. In diesem Fall wird die von der formatString-Komponente im Formatelement angegebene Formatzeichenfolge (sofern vorhanden) ignoriert.In this case, the format string specified by the formatString component in the format item, if it's present, is ignored.

Die Ausrichtung wird angewendet, nachdem die vorhergehenden Schritte durchgeführt wurden.Alignment is applied after the preceding steps have been performed.

CodebeispieleCode Examples

Das folgende Beispiel stellt eine Zeichenfolge dar, die mit der kombinierten Formatierung erstellt wurde, und eine weitere, die mit der ToString-Methode eines Objekts erstellt wurde.The following example shows one string created using composite formatting and another created using an object's ToString method. Beide Formatierungen führen zum gleichen Ergebnis.Both types of formatting produce equivalent results.

string FormatString1 = String.Format("{0:dddd MMMM}", DateTime.Now);
string FormatString2 = DateTime.Now.ToString("dddd MMMM");
Dim FormatString1 As String = String.Format("{0:dddd MMMM}", DateTime.Now)
Dim FormatString2 As String = DateTime.Now.ToString("dddd MMMM") 

Wenn das aktuelle Datum ein Donnerstag im Mai ist, lautet der Wert beider Zeichenfolgen im vorherigen Beispiel Thursday May in der Kultur Englisch (USA).Assuming that the current day is a Thursday in May, the value of both strings in the preceding example is Thursday May in the U.S. English culture.

Console.WriteLine stellt die gleiche Funktionalität wie String.Format bereit.Console.WriteLine exposes the same functionality as String.Format. Der einzige Unterschied zwischen den beiden Methoden besteht darin, dass String.Format das Ergebnis als Zeichenfolge zurückgibt, während Console.WriteLine das Ergebnis in den Ausgabestrom schreibt, der dem Console-Objekt zugeordnet ist.The only difference between the two methods is that String.Format returns its result as a string, while Console.WriteLine writes the result to the output stream associated with the Console object. Im folgenden Beispiel wird der Wert von Console.WriteLine mit der MyInt-Methode als Währungswert formatiert.The following example uses the Console.WriteLine method to format the value of MyInt to a currency value.

int MyInt = 100;
Console.WriteLine("{0:C}", MyInt);
// The example displays the following output 
// if en-US is the current culture:
//        $100.00
Dim MyInt As Integer = 100
Console.WriteLine("{0:C}", MyInt)
' The example displays the following output
' if en-US is the current culture:
'        $100.00

Das folgende Beispiel veranschaulicht die Formatierung mehrerer Objekte, wobei ein Objekt auf zwei Arten formatiert wird.The following example demonstrates formatting multiple objects, including formatting one object two different ways.

string myName = "Fred";
Console.WriteLine(String.Format("Name = {0}, hours = {1:hh}, minutes = {1:mm}",
      myName, DateTime.Now));
// Depending on the current time, the example displays output like the following:
//    Name = Fred, hours = 11, minutes = 30                 
Dim myName As String = "Fred"
Console.WriteLine(String.Format("Name = {0}, hours = {1:hh}, minutes = {1:mm}", _
                  myName, DateTime.Now))
' Depending on the current time, the example displays output like the following:
'    Name = Fred, hours = 11, minutes = 30                 

Das folgende Beispiel veranschaulicht die Verwendung der Ausrichtung beim Formatieren.The following example demonstrates the use of alignment in formatting. Die zu formatierenden Argumente werden zwischen senkrechte Striche (|) platziert, um die resultierende Ausrichtung zu kennzeichnen.The arguments that are formatted are placed between vertical bar characters (|) to highlight the resulting alignment.

string myFName = "Fred";
string myLName = "Opals";
int myInt = 100;
string FormatFName = String.Format("First Name = |{0,10}|", myFName);
string FormatLName = String.Format("Last Name = |{0,10}|", myLName);
string FormatPrice = String.Format("Price = |{0,10:C}|", myInt); 
Console.WriteLine(FormatFName);
Console.WriteLine(FormatLName);
Console.WriteLine(FormatPrice);
Console.WriteLine();

FormatFName = String.Format("First Name = |{0,-10}|", myFName);
FormatLName = String.Format("Last Name = |{0,-10}|", myLName);
FormatPrice = String.Format("Price = |{0,-10:C}|", myInt);
Console.WriteLine(FormatFName);
Console.WriteLine(FormatLName);
Console.WriteLine(FormatPrice);
// The example displays the following output on a system whose current
// culture is en-US:
//          First Name = |      Fred|
//          Last Name = |     Opals|
//          Price = |   $100.00|
//
//          First Name = |Fred      |
//          Last Name = |Opals     |
//          Price = |$100.00   |
   Dim myFName As String = "Fred"
   Dim myLName As String = "Opals"

   Dim myInt As Integer = 100
   Dim FormatFName As String = String.Format("First Name = |{0,10}|", myFName)
   Dim FormatLName As String = String.Format("Last Name = |{0,10}|", myLName)
   Dim FormatPrice As String = String.Format("Price = |{0,10:C}|", myInt)
   Console.WriteLine(FormatFName)
   Console.WriteLine(FormatLName)
   Console.WriteLine(FormatPrice)
   Console.WriteLine()
   
   FormatFName = String.Format("First Name = |{0,-10}|", myFName)
   FormatLName = String.Format("Last Name = |{0,-10}|", myLName)
   FormatPrice = String.Format("Price = |{0,-10:C}|", myInt)
   Console.WriteLine(FormatFName)
   Console.WriteLine(FormatLName)
   Console.WriteLine(FormatPrice)
   ' The example displays the following output on a system whose current
   ' culture is en-US:
   '          First Name = |      Fred|
   '          Last Name = |     Opals|
   '          Price = |   $100.00|
   '
   '          First Name = |Fred      |
   '          Last Name = |Opals     |
   '          Price = |$100.00   |

Siehe auchSee also