String.Format Methode

Definition

Konvertiert auf der Grundlage der angegebenen Formate den Wert von Objekten in Zeichenfolgen und fügt sie in eine andere Zeichenfolge ein.Converts the value of objects to strings based on the formats specified and inserts them into another string.

Wenn Sie die String.Format-Methode noch nicht kennen, lesen Sie den Abschnitt zur String.Format-Methode, um sich einen Überblick zu verschaffen.If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview.

Eine allgemeine Dokumentation zur String.Format-Methode finden Sie im Abschnitt Hinweise.See the Remarks section for general documentation for the String.Format method.

Überlädt

Format(String, Object)

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

Format(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts.Replaces the format item or items in a specified string with the string representation of the corresponding object. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

Format(String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.Replaces the format items in a string with the string representation of two specified objects.

Format(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.Replaces the format items in a string with the string representation of two specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

Format(String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.Replaces the format items in a string with the string representation of three specified objects.

Format(IFormatProvider, String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.Replaces the format items in a string with the string representation of three specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen.An parameter supplies culture-specific formatting information.

Beispiele

Viele Beispiele, die die Format-Methode aufzurufen, werden über den Abschnitt " Hinweise " in diesem Artikel überschrieben.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Hinweis

Einige der C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Wenn vorhanden, klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.When present, select the Run button to run an example in an interactive window. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen.Once you execute the code, you can modify it and run the modified code by selecting Run again. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Sie können auch einen kompletten Satz String.Format Beispiele herunterladen, die ein .net Core 2,0- C# Projekt für und ein .net Core 2,0-Projekt für Visual Basicaus dem dotnet/Samples GitHub-Repositoryenthalten.You can also download a complete set of String.Format examples, which are included a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Im folgenden finden Sie einige Beispiele, die im Artikel enthalten sind:The following are some of the examples included in the article:

Erstellen einer Format ZeichenfolgeCreate a format string

Einfügen einer ZeichenfolgeInserting a string
Das Format ElementThe format item
Formatieren von Elementen mit demselben IndexFormat items that have the same index

Formatierte Ausgabe formatierenControl formatted output

Steuern der FormatierungControlling formatting
Steuern des AbstandsControlling spacing
Steuern der AusrichtungControlling alignment
Steuern der Anzahl von ganzzahligen ZiffernControlling the number of integral digits
Steuern der Anzahl der Ziffern nach dem DezimaltrennzeichenControlling the number of digits after the decimal separator
Einschließen von literalklammern in einer Ergebnis ZeichenfolgeIncluding literal braces in a result string

Format Zeichenfolgen Kultur abhängig machenMake format strings culture-sensitive

Kultur abhängige FormatierungCulture-sensitive formatting

Anpassen des Formatierungs VorgangsCustomize the formatting operation

Ein benutzerdefinierter Formatierungs VorgangA custom formatting operation
Ein Abfang Anbieter und ein Roman-formatiererformatiererAn intercept provider and Roman numeral formatter

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

In diesem AbschnittIn this section:

Beginnen Sie mit der String. Format-Methode Get started with the String.Format method
Welche Methode rufe ich auf? Which method do I call?
Die Format-Methode in kurzer The Format method in brief
Das Format Element The Format item
Formatieren von Argumenten How arguments are formatted
Formatieren Sie Elemente, die denselben Index aufweisen Format items that have the same index
Formatierung und Kultur Formatting and culture
Benutzerdefinierte Formatierungs Vorgänge Custom formatting operations
String. Format Q & AString.Format Q & A

Beginnen Sie mit der String. Format-MethodeGet started with the String.Format method

Verwenden Sie String.Format, wenn Sie den Wert eines Objekts, einer Variablen oder eines Ausdrucks in eine andere Zeichenfolge einfügen müssen.Use String.Format if you need to insert the value of an object, variable, or expression into another string. Beispielsweise können Sie den Wert eines Decimal Werts in eine Zeichenfolge einfügen, damit Sie dem Benutzer als einzelne Zeichenfolge angezeigt wird:For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
                           pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0} per ounce.",
                                pricePerOunce)
' Result: The current price is 17.36 per ounce.

Und Sie können die Formatierung dieses Werts Steuern:And you can control that value's formatting:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0:C2} per ounce.",
                           pricePerOunce);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                                pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

Neben der Formatierung können Sie auch die Ausrichtung und den Abstand steuern.Besides formatting, you can also control alignment and spacing.

Einfügen einer ZeichenfolgeInserting a string

String.Format beginnt mit einer Format Zeichenfolge, gefolgt von einem oder mehreren Objekten oder Ausdrücken, die in Zeichen folgen konvertiert und an einer bestimmten Stelle in der Format Zeichenfolge eingefügt werden.String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. Beispiel:For example:

Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4d
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

Der {0} in der Format Zeichenfolge ist ein Format Element.The {0} in the format string is a format item. 0 ist der Index des Objekts, dessen Zeichen folgen Wert an dieser Position eingefügt wird.0 is the index of the object whose string value will be inserted at that position. (Indizes beginnen bei 0.) Wenn das einzufügende Objekt keine Zeichenfolge ist, wird die ToString-Methode aufgerufen, um Sie in eine zu konvertieren, bevor Sie in die Ergebnis Zeichenfolge eingefügt wird.(Indexes start at 0.) If the object to be inserted is not a string, its ToString method is called to convert it to one before inserting it in the result string.

Im folgenden finden Sie ein weiteres Beispiel, in dem zwei Format Elemente und zwei-Objekte in der Objektliste verwendet werden:Here's another example that uses two format items and two objects in the object list:

String^ s = String::Format("At {0}, the temperature is {1}°C.",
                           DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                                Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

Sie können beliebig viele Format Elemente und beliebig viele Objekte in der Objektliste enthalten, solange der Index jedes Format Elements über ein entsprechendes Objekt in der Objektliste verfügt.You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. Außerdem müssen Sie sich keine Gedanken darüber machen, welche Überlastung Sie aufrufen. der Compiler wählt den entsprechenden für Sie aus.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

Steuern der FormatierungControlling formatting

Sie können den Index in einem Format Element mit einer Format Zeichenfolge befolgen, um zu steuern, wie ein Objekt formatiert wird.You can follow the index in a format item with a format string to control how an object is formatted. {0:d} wendet z. b. die Format Zeichenfolge "d" auf das erste Objekt in der Objektliste an.For example, {0:d} applies the "d" format string to the first object in the object list. Im folgenden finden Sie ein Beispiel mit einem einzelnen-Objekt und zwei Format Elementen:Here is an example with a single object and two format items:

String^ s = String::Format("It is now {0:d} at {0:t}",
                           DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
                                Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Eine Reihe von Typen unterstützen Format Zeichenfolgen, einschließlich aller numerischen Typen ( standardmäßige und benutzerdefinierte Format Zeichenfolgen), Datums-und Uhrzeitangaben ( standardmäßige und benutzerdefinierte Format Zeichenfolgen) und Zeitintervallen (sowohl Standard benutzerdefinierte Format Zeichenfolgen), alle Enumerationstypen Enumerationstypenund GUIDs.A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. Sie können auch Unterstützung für Format Zeichenfolgen zu ihren eigenen Typen hinzufügen.You can also add support for format strings to your own types.

Steuern des AbstandsControlling spacing

Sie können die Breite der Zeichenfolge, die in die Ergebnis Zeichenfolge eingefügt wird, mithilfe von Syntax definieren, wie z. b. {0,12}, die eine Zeichenfolge mit 12 Zeichen einfügt.You can define the width of the string that is inserted into the result string by using syntax such as {0,12}, which inserts a 12-character string. In diesem Fall wird die Zeichen folgen Darstellung des ersten Objekts rechtsbündig im Feld mit 12 Zeichen ausgerichtet.In this case, the string representation of the first object is right-aligned in the 12-character field. (Wenn die Zeichen folgen Darstellung des ersten Objekts mehr als 12 Zeichen lang ist, wird jedoch die bevorzugte Feldbreite ignoriert, und die gesamte Zeichenfolge wird in die Ergebnis Zeichenfolge eingefügt.)(If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)

Im folgenden Beispiel wird ein Zeichen aus 6 Zeichen definiert, das die Zeichenfolge "Year" und einige Jahr-Zeichen folgen enthält, sowie ein Feld mit 15 Zeichen, das die Zeichenfolge "Population" und einige auffüllungs Daten enthalten soll.The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. Beachten Sie, dass die Zeichen rechtsbündig in dem Feld ausgerichtet sind.Note that the characters are right-aligned in the field.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
   sb->AppendFormat("{0,6} {1,15:N0}\n",
                    years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
     int[] years = { 2013, 2014, 2015 };
     int[] population = { 1025632, 1105967, 1148203 };
     var sb = new System.Text.StringBuilder();
     sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
     for (int index = 0; index < years.Length; index++)
        sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

     Console.WriteLine(sb);

     // Result:
     //      Year      Population
     //
     //      2013       1,025,632
     //      2014       1,105,967
     //      2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                        "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
   sb.AppendFormat("{0,6} {1,15:N0}{2}",
                   years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

Steuern der AusrichtungControlling alignment

Standardmäßig werden Zeichen folgen rechtsbündig ausgerichtet, wenn Sie eine Feldbreite angeben.By default, strings are right-aligned within their field if you specify a field width. Wenn Zeichen folgen in einem Feld linksbündig ausgerichtet werden sollen, wird der Feldbreite ein negatives Vorzeichen vorangestellt, z. b. {0,-12}, um ein nach links Bündiges Feld mit 12 Zeichen zu definieren.To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12} to define a 12-character left-aligned field.

Das folgende Beispiel ähnelt dem vorherigen, mit der Ausnahme, dass es sowohl Bezeichnungen als auch Daten linksbündig ausgerichtet ist.The following example is similar to the previous one, except that it left-aligns both labels and data.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
String^ s = String::Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years->Length; index++)
   s += String::Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                                "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
   s += String.Format("{0,-10} {1,-10:N0}{2}",
                      years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format verwendet die Funktion für die kombinierte Formatierung.String.Format makes use of the composite formatting feature. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung.For more information, see Composite Formatting.

Welche Methode rufe ich auf?Which method do I call?

BeschreibungTo CallCall
Formatiert ein oder mehrere-Objekte, indem die Konventionen der aktuellen Kultur verwendet werden.Format one or more objects by using the conventions of the current culture. Mit Ausnahme der über Ladungen, die einen provider-Parameter enthalten, enthalten die verbleibenden Format Überladungen einen String-Parameter, gefolgt von einem oder mehreren Objekt Parametern.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. Aus diesem Grund müssen Sie nicht ermitteln, welche Format Überladung Sie aufrufen möchten.Because of this, you don't have to determine which Format overload you intend to call. Der sprach Compiler wählt die entsprechende Überladung aus den über Ladungen aus, die nicht über einen provider Parameter verfügen, basierend auf der Argumentliste.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Wenn Ihre Argumentliste beispielsweise fünf Argumente enthält, ruft der Compiler die Format(String, Object[])-Methode auf.For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Formatieren eines oder mehrerer-Objekte mithilfe der Konventionen einer bestimmten Kultur.Format one or more objects by using the conventions of a specific culture. Auf jede Format Überladung, die mit einem provider-Parameter beginnt, folgt ein String Parameter und mindestens ein Objekt Parameter.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. Aus diesem Grund müssen Sie nicht ermitteln, welche spezifische Format Überladung Sie aufrufen möchten.Because of this, you don't have to determine which specific Format overload you intend to call. Der sprach Compiler wählt basierend auf der Argumentliste die entsprechende Überladung aus den über Ladungen aus, die über einen provider-Parameter verfügen.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Wenn Ihre Argumentliste beispielsweise fünf Argumente enthält, ruft der Compiler die Format(IFormatProvider, String, Object[])-Methode auf.For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Führen Sie einen benutzerdefinierten Formatierungs Vorgang entweder mit einer ICustomFormatter-Implementierung oder einer IFormattable-Implementierung aus.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. Eine der vier über Ladungen mit einem provider-Parameter.Any of the four overloads with a provider parameter. Der Compiler wählt basierend auf der Argumentliste die entsprechende Überladung aus den über Ladungen aus, die über einen provider-Parameter verfügen.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Die Format-Methode kurzThe Format method in brief

Jede Überladung der Format-Methode verwendet die Funktion für die kombinierte Formatierung , um null-basierte indizierte Platzhalter ( Format Elemente) in einer zusammengesetzten Format Zeichenfolge einzuschließen.Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. Zur Laufzeit wird jedes Format Element durch die Zeichen folgen Darstellung des entsprechenden Arguments in einer Parameterliste ersetzt.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. Wenn der Wert des Arguments nullist, wird das Format Element durch String.Emptyersetzt.If the value of the argument is null, the format item is replaced with String.Empty. Beispielsweise enthält der folgende Aufrufe der Format(String, Object, Object, Object)-Methode eine Format Zeichenfolge mit drei Format Elementen, {0}, {1}und {2}sowie eine Argumentliste mit drei Elementen.For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.

using namespace System;

void main()
{
   DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0); 
   String^ city = "Chicago";
   int temp = -16;
   String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp);
   Console::WriteLine(output);
}
// The example displays the following output: 
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
Dim dat As Date = #1/17/2012 9:30AM# 
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                     dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   

Das Format ElementThe format item

Ein Format Element weist folgende Syntax auf:A format item has this syntax:

{index[,alignment][:formatString]}  

Eckige Klammern kennzeichnen optionale Elemente.Brackets denote optional elements. Die öffnenden und schließenden geschweiften Klammern sind erforderlich.The opening and closing braces are required. (Um eine Literale öffnende oder schließende geschweifte Klammer in der Format Zeichenfolge einzuschließen, lesen Sie den Abschnitt escapeklammern im Artikel zusammen gesetzte Formatierung .)(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Ein Format Element zum Formatieren eines Währungs Werts könnte z. b. folgendermaßen aussehen:For example, a format item to format a currency value might appear like this:

String::Format("{0,-10:C}", (Decimal) 126347.89);         
var value = String.Format("{0,-10:C}", 126347.89m);         
Console.WriteLine(value);
String.Format("{0,-10:C}", 126347.89d)        

Ein Format Element verfügt über die folgenden Elemente:A format item has the following elements:

indexindex
Der null basierte Index des Arguments, dessen Zeichen folgen Darstellung an dieser Position in der Zeichenfolge eingefügt werden soll.The zero-based index of the argument whose string representation is to be included at this position in the string. Wenn dieses Argument nullist, wird an dieser Position in der Zeichenfolge eine leere Zeichenfolge eingefügt.If this argument is null, an empty string will be included at this position in the string.

alignmentalignment
Dies ist optional.Optional. Eine ganze Zahl mit Vorzeichen, die die Gesamtlänge des Felds angibt, in das das Argument eingefügt wird, und ob es rechtsbündig (eine positive ganze Zahl) oder linksbündig (eine negative Ganzzahl) ist.A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). Wenn Sie die Ausrichtungweglassen, wird die Zeichen folgen Darstellung des entsprechenden Arguments in ein Feld ohne führende oder nachfolgende Leerzeichen eingefügt.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

Wenn der Wert der Ausrichtung kleiner als die Länge des einzufügenden Arguments ist, wird die Ausrichtung ignoriert, und die Länge der Zeichen folgen Darstellung des Arguments wird als Feldbreite verwendet.If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.

formatStringformatString
Dies ist optional.Optional. Eine Zeichenfolge, die das Format der Ergebnis Zeichenfolge des entsprechenden Arguments angibt.A string that specifies the format of the corresponding argument's result string. Wenn Sie Format Zeichenfolgeweglassen, wird die Parameter lose ToString-Methode des entsprechenden Arguments aufgerufen, um die Zeichen folgen Darstellung zu schaffen.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. Wenn Sie Format Zeichenfolgeangeben, muss das Argument, auf das vom Format Element verwiesen wird, die IFormattable-Schnittstelle implementieren.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. Typen, die Format Zeichenfolgen unterstützen, sind:Types that support format strings include:

Beachten Sie jedoch, dass jeder benutzerdefinierte Typ IFormattable implementieren oder die IFormattable Implementierung eines vorhandenen Typs erweitern kann.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

Im folgenden Beispiel werden die Argumente alignment und formatString verwendet, um eine formatierte Ausgabe zu liefern.The following example uses the alignment and formatString arguments to produce formatted output.

using namespace System;

void main()
{
   // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
   array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^> 
         { gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277, 
                        DateTime(1950, 1, 1), 1970358),
         gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995, 
                        DateTime(1950, 1, 1), 7891957),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808, 
                        DateTime(1950, 1, 1), 3620962),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452, 
                        DateTime(1950, 1, 1), 1849568) };

   // Display header
   String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                   "City", "Year", "Population", "Change (%)");
   Console::WriteLine(header);
   String^ output;      
   for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
      output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                              city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
                              (city->Item5 - city->Item3)/ (double)city->Item3);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities = 
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                   new DateTime(1950, 1, 1), 7891957),  
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                   new DateTime(1950, 1, 1), 3620962),  
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
Module Example
   Public Sub Main()
      ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),  
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),  
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }

      ' Display header
      Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
      Console.WriteLine(header)
      Console.WriteLine()
      For Each city In cities
         Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3)/city.Item3)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'    
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Formatieren von ArgumentenHow arguments are formatted

Format Elemente werden sequenziell vom Anfang der Zeichenfolge verarbeitet.Format items are processed sequentially from the beginning of the string. Jedes Format Element verfügt über einen Index, der einem Objekt in der Argumentliste der Methode entspricht.Each format item has an index that corresponds to an object in the method's argument list. Die Format-Methode ruft das-Argument ab und leitet seine Zeichen folgen Darstellung wie folgt ab:The Format method retrieves the argument and derives its string representation as follows:

Ein Beispiel, das Aufrufe der ICustomFormatter.Format-Methode abfängt und Ihnen ermöglicht, die Informationen anzuzeigen, die die Format-Methode an eine Formatierungs Methode für jedes Format Element in einer zusammengesetzten Format Zeichenfolge übergibt, finden Sie unter Beispiel: ein Abfang Anbieter und eine römische Zahl. Formatierer.For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.

Weitere Informationen finden Sie im Abschnitt " Verarbeitungsreihenfolge " im Artikel zur zusammen gesetzten Formatierung .For more information, see the Processing Order section in the Composite Formatting article.

Formatieren von Elementen mit demselben IndexFormat items that have the same index

Die Format-Methode löst eine FormatException Ausnahme aus, wenn der Index eines Index Elements größer oder gleich der Anzahl der Argumente in der Argumentliste ist.The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. format können jedoch mehr Formatierungs Elemente enthalten, als Argumente vorhanden sind, solange mehrere Format Elemente denselben Index aufweisen.However, format can include more format items than there are arguments, as long as multiple format items have the same index. Im folgenden Beispiel enthält die Argumentliste im Format(String, Object)-Methode ein einzelnes Argument, die Format Zeichenfolge enthält jedoch zwei Format Elemente: eine zeigt den Dezimalwert einer Zahl an, und die andere zeigt den Hexadezimalwert an.In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.

short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
   string formatString = String.Format("{0,10:G}: {0,10:X}", value);
   Console.WriteLine(formatString);
}   
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF
Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
      Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
      Console.WriteLine()
      For Each value As Short In values
         Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
         Console.WriteLine(formatString)
      Next        
   End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Formatierung und KulturFormatting and culture

Im Allgemeinen werden Objekte in der Argumentliste mithilfe der Konventionen der aktuellen Kultur, die von der CultureInfo.CurrentCulture-Eigenschaft zurückgegeben wird, in ihre Zeichen folgen Darstellungen konvertiert.Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. Sie können dieses Verhalten steuern, indem Sie eine der über Ladungen von Format aufrufen, die einen provider-Parameter enthält.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. Der provider-Parameter ist eine IFormatProvider Implementierung, die benutzerdefinierte und kulturspezifische Formatierungsinformationen bereitstellt, die zum moderieren des Formatierungs Vorgangs verwendet werden.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

Die IFormatProvider-Schnittstelle verfügt über einen einzelnen Member, GetFormat, der für die Rückgabe des Objekts zuständig ist, das Formatierungsinformationen bereitstellt.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .Net verfügt über drei IFormatProvider-Implementierungen, die kulturspezifische Formatierung bereitstellen:.NET has three IFormatProvider implementations that provide culture-specific formatting:

Benutzerdefinierte Formatierungs VorgängeCustom formatting operations

Sie können auch die über Ladungen der Format-Methode aufrufen, die über einen provider-Parameter vom Typ IFormatProvider verfügen, um benutzerdefinierte Formatierungs Vorgänge auszuführen.You can also call the any of the overloads of the Format method that have a provider parameter of type IFormatProvider to perform custom formatting operations. Beispielsweise können Sie eine ganze Zahl als Identifikationsnummer oder als Telefonnummer formatieren.For example, you could format an integer as an identification number or as a telephone number. Um eine benutzerdefinierte Formatierung auszuführen, muss das provider-Argument sowohl die IFormatProvider als auch die ICustomFormatter-Schnittstelle implementieren.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. Wenn der Format-Methode eine ICustomFormatter Implementierung als provider Argument übermittelt wird, ruft die Format-Methode ihre IFormatProvider.GetFormat-Implementierung auf und fordert ein Objekt vom Typ ICustomFormatteran.When the Format method is passed an ICustomFormatter implementation as the provider argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. Anschließend wird die Format-Methode des zurückgegebenen ICustomFormatter Objekts aufgerufen, um jedes Format Element in der an ihn weiter gegebenen Verbund Zeichenfolge zu formatieren.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

Weitere Informationen zum Bereitstellen von benutzerdefinierten Formatierungs Lösungen finden Sie unter Gewusst wie: definieren und Verwenden von benutzerdefinierten Zahlen Format Anbietern und ICustomFormatter.For more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. Ein Beispiel, das ganze Zahlen in formatierte benutzerdefinierte Zahlen konvertiert, finden Sie unter Beispiel: ein benutzerdefinierter Formatierungs Vorgang.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Ein Beispiel, in dem nicht signierte Bytes in römische Zahlen konvertiert werden, finden Sie unter Beispiel: ein Abfang Anbieter und ein Roman-Zahlen FormatierungsProgramm.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Beispiel: ein benutzerdefinierter Formatierungs VorgangExample: A custom formatting operation

In diesem Beispiel wird ein Format Anbieter definiert, der einen ganzzahligen Wert als Kundenkonto Nummer in der Form x-xxxxx-xx formatiert.This example defines a format provider that formats an integer value as a customer account number in the form x-xxxxx-xx.

using namespace System;

ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType) 
   {
      if (formatType == ICustomFormatter::typeid)        
         return this; 
      else 
         return nullptr; 
   }
   
   virtual String^ Format(String^ format, 
                   Object^ arg, 
                   IFormatProvider^ formatProvider) 
   {                       
      if (! this->Equals(formatProvider))
      {
         return nullptr;
      }
      else
      {
         if (String::IsNullOrEmpty(format)) 
            format = "G";
         
         String^ customerString = arg->ToString();
         if (customerString->Length < 8)
            customerString = customerString->PadLeft(8, '0');
         
         format = format->ToUpper();
         if (format == L"G") 
               return customerString->Substring(0, 1) + "-" +
                                     customerString->Substring(1, 5) + "-" +
                                     customerString->Substring(6);
         else if (format == L"S")                          
               return customerString->Substring(0, 1) + "/" +
                                     customerString->Substring(1, 5) + "/" +
                                     customerString->Substring(6);
         else if (format == L"P")
               return customerString->Substring(0, 1) + "." +
                                     customerString->Substring(1, 5) + "." +
                                     customerString->Substring(6);
         else
               throw gcnew FormatException( 
                         String::Format("The '{0}' format specifier is not supported.", format));
         }
    }   
};

void main()
{
   int acctNumber = 79203159;
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
   try {
      Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
   }
   catch (FormatException^ e) {
      Console::WriteLine(e->Message);
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : 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 (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type 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 Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

Beispiel: ein Abfang Anbieter und ein römischer Zahlen FormatiererExample: An intercept provider and Roman numeral formatter

In diesem Beispiel wird ein benutzerdefinierter Format Anbieter definiert, der die ICustomFormatter und IFormatProvider Schnittstellen implementiert, um zwei Dinge auszuführen:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Es zeigt die Parameter an, die an die ICustomFormatter.Format Implementierung übertragen werden.It displays the parameters passed to its ICustomFormatter.Format implementation. Dadurch können wir sehen, welche Parameter die Format(IFormatProvider, String, Object[]) Methode an die Implementierung der benutzerdefinierten Formatierung für jedes Objekt übergibt, das Sie zu formatieren versucht.This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. Dies kann hilfreich sein, wenn Sie Ihre Anwendung debuggen.This can be useful when you're debugging your application.

  • Wenn das zu formatierende Objekt ein Bytewert ohne Vorzeichen ist, der mit der Standardformat Zeichenfolge "R" formatiert werden soll, formatiert das benutzerdefinierte Formatierungs Programm den numerischen Wert als römische Ziffer.If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.

using namespace System;
using namespace System::Globalization;

ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType)
   {
      if (formatType == ICustomFormatter::typeid)   
         return this;
      else
         return nullptr;
   }
   
   virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider) 
   {
      // Display information about method call.
      String^ formatString = format != nullptr ? format : "<null>";
      Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj != nullptr ? obj : "<null>", formatString);
                        
      if (obj == nullptr) return String::Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String^ returnString = String::Empty;

         // Get the hundreds digit(s)
         result = Math::DivRem(value, 100, remainder);
         if (result > 0)  
            returnString = gcnew String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math::DivRem(value, 50, remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math::DivRem(value, 10, remainder);
         if (result > 0)
            returnString += gcnew String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math::DivRem(value, 5, remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += gcnew String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString->IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString->IndexOf("L"); 
            if ((xPos >= 0) & (xPos == pos - 1))
               returnString = returnString->Replace("LXXXX", "XC");
            else
               returnString = returnString->Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString->IndexOf("IIII");
         if (pos >= 0)
            if (returnString->IndexOf("V") >= 0)
               returnString = returnString->Replace("VIIII", "IX");
            else
               returnString = returnString->Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj->GetType() == IFormattable::typeid)
         return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
      else
         return obj->ToString();
   }
};

void main()
{
   int n = 10;
   double value = 16.935;
   DateTime day = DateTime::Now;
   InterceptProvider^ provider = gcnew InterceptProvider();
   Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
   Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ", 
                                    (DayOfWeek) DateTime::Now.DayOfWeek));
   Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
   Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
Imports System.Globalization

Public Class InterceptProvider : 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, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today", 
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}", 
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'    
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'    
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'    
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

String. Format Q & AString.Format Q & A

Warum empfehlen Sie die Zeichen folgen Interpolationsmethode für Aufrufe der String.Format-Methode?Why do you recommend string interpolation over calls to the String.Format method?

Zeichen folgen Interpolationen:String interpolation is:

  • Flexibler.More flexible. Sie kann in einer beliebigen Zeichenfolge verwendet werden, ohne dass eine Methode aufgerufen werden muss, die die kombinierte Formatierung unterstützt.It can be used in any string without requiring a call to a method that supports composite formatting. Andernfalls müssen Sie die Format-Methode oder eine andere Methode, die die kombinierte Formatierung unterstützt, wie z. b. Console.WriteLine oder StringBuilder.AppendFormat, aufzurufen.Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.

  • Besser lesbar.More readable. Da der Ausdruck, der in eine Zeichenfolge eingefügt werden soll, im interinterinterierten Ausdruck und nicht in einer Argumentliste angezeigt wird, sind interpoliert Zeichen folgen weitaus einfacher zu programmieren und zu lesen.Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. Aufgrund der besseren Lesbarkeit können interinterpolierte Zeichen folgen nicht nur Aufrufe von Methoden für den zusammengesetzten Format ersetzen, Sie können jedoch auch in Zeichenfolgenverkettungs Vorgängen verwendet werden, um präziseren, klareren Code zu erzielen.Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.

Ein Vergleich der folgenden beiden Codebeispiele veranschaulicht die Überlegenheit von interpoliert-Zeichen folgen über die Zeichen folgen Verkettung und Aufrufe von Methoden für die kombinierte Formatierung.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. Durch die Verwendung mehrerer Zeichen folgen Verkettungs Vorgänge im folgenden Beispiel werden ausführlicher und schwer zu lesende Code erzeugt.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = names[0] + ", " + names[1] + ", " + names[2] + ", " + 
                  names[3] + ", " + names[4] + ", " + names[5] + ", " + 
                  names[6];  

  output += "\n";  
  var date = DateTime.Now;
  output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                          date, date.DayOfWeek);
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " + 
                   names(3) + ", " + names(4) + ", " + names(5) + ", " + 
                   names(6)  
    
      output += vbCrLf  
      Dim dat = DateTime.Now
      output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                              dat, dat.DayOfWeek)
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Im Gegensatz dazu erzeugt die Verwendung von interpoliert Zeichen folgen im folgenden Beispiel viel klareren, präziseren Code als die Zeichen folgen-Verkettungs Anweisung und den aufzurufenden Format Methode im vorherigen Beispiel.In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " + 
                  $"{names[5]}, {names[6]}";  

  var date = DateTime.Now;
  output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " + 
                   $"{names(5)}, {names(6)}"  
    
      Dim dat = DateTime.Now
      output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}." 
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Wo finde ich eine Liste der vordefinierten Format Zeichenfolgen, die mit Format Elementen verwendet werden können?Where can I find a list of the predefined format strings that can be used with format items?

Gewusst wie die Ausrichtung der Ergebnis Zeichenfolgen steuern, die Format Elemente ersetzen?How do I control the alignment of the result strings that replace format items?

Die allgemeine Syntax eines Format Elements lautet wie folgt:The general syntax of a format item is:

{index[,alignment][: formatString]}  

Where Alignment ist eine Ganzzahl mit Vorzeichen, die die Feldbreite definiert.where alignment is a signed integer that defines the field width. Wenn dieser Wert negativ ist, wird der Text im Feld linksbündig ausgerichtet.If this value is negative, text in the field is left-aligned. Wenn er positiv ist, wird der Text rechtsbündig ausgerichtet.If it is positive, text is right-aligned.

Gewusst wie die Anzahl der Ziffern nach dem Dezimaltrennzeichen Steuern?How do I control the number of digits after the decimal separator?

Alle standardmäßigen Zahlenformat Zeichenfolgen außer "D" (die nur mit ganzen Zahlen verwendet werden), "G", "R" und "X" lassen einen Genauigkeits Bezeichner zu, der die Anzahl der Dezimalstellen in der Ergebnis Zeichenfolge definiert.All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. Im folgenden Beispiel werden standardmäßige numerische Format Zeichenfolgen verwendet, um die Anzahl von Dezimalstellen in der Ergebnis Zeichenfolge zu steuern.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values) {
   result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                          Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
   Console.WriteLine(result);
}                           
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %
Module Example
   Public Sub Main()
      Dim values() As Object = { 1603, 1794.68235, 15436.14 }
      Dim result As String
      For Each value In values
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
         Console.WriteLine(result) 
         Console.WriteLine()
      Next                             
   End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Wenn Sie eine benutzerdefinierte numerische Format Zeichenfolgeverwenden, verwenden Sie den Format Bezeichner "0", um die Anzahl von Dezimalstellen in der Ergebnis Zeichenfolge zu steuern, wie im folgenden Beispiel gezeigt.If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.

decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//        16309.54360    16,309.54    16309.544
Module Example
   Public Sub Main()
      Dim value As Decimal = 16309.5436d
      Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

Gewusst wie die Anzahl der ganzzahligen Ziffern Steuern?How do I control the number of integral digits?

Standardmäßig werden bei Formatierungs Vorgängen nur ganzzahlige Ziffern ungleich Null angezeigt.By default, formatting operations only display non-zero integral digits. Wenn Sie ganze Zahlen formatieren, können Sie einen Genauigkeits Bezeichner mit den standardmäßigen Format Zeichenfolgen "D" und "X" verwenden, um die Anzahl der Ziffern zu steuern.If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.

int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
//     001326   0000052E
Module Example
   Public Sub Main()
      Dim value As Integer = 1326
      Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       001326   0000052E

Sie können eine Ganzzahl oder eine Gleit Komma Zahl mit führenden Nullen auffüllen, um eine Ergebnis Zeichenfolge mit einer angegebenen Anzahl von ganzzahligen Ziffern zu entwickeln, indem Sie den benutzerdefinierten numerischen FormatBezeichner "0" verwenden, wie im folgenden Beispiel gezeigt.You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.

int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0
Module Example
   Public Sub Main()
      Dim value As Integer = 16342
      Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

Wie viele Elemente kann ich in die Liste "Format" einschließen?How many items can I include in the format list?

Es gibt keine praktische Beschränkung.There is no practical limit. Der zweite Parameter der Format(IFormatProvider, String, Object[])-Methode wird mit dem ParamArrayAttribute-Attribut markiert, sodass Sie entweder eine durch Trennzeichen getrennte Liste oder ein Objekt Array als Format Liste einschließen können.The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.

Gewusst wie in die Ergebnis Zeichenfolge Literale geschweifte Klammern ("{" und "}") einschließen?How do I include literal braces ("{" and "}") in the result string?

Beispielsweise verhindern Sie, dass der folgende Methodenaufrufe eine FormatException Ausnahme auslöst?For example, how do you prevent the following method call from throwing a FormatException exception?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose)

Eine einzelne öffnende oder schließende geschweifte Klammer wird immer als Anfang oder Ende eines Format Elements interpretiert.A single opening or closing brace is always interpreted as the beginning or end of a format item. Damit er buchstäblich interpretiert wird, muss er mit Escapezeichen versehen werden.To be interpreted literally, it must be escaped. Sie können eine Klammer mit Escapezeichen versehen, indem Sie eine weitere geschweifter Klammer ("{{" und "}}" anstelle von "{" und "}") hinzufügen, wie im folgenden Methoden aufzurufen:You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose)

Selbst mit Escapezeichen versehene geschweifte Klammern können jedoch problemlos interpretiert werdenHowever, even escaped braces are easily misinterpreted. Sie sollten geschweifte Klammern in die Format Liste einschließen und Format Elemente verwenden, um Sie in die Ergebnis Zeichenfolge einzufügen, wie im folgenden Beispiel gezeigt.We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}");
Console.WriteLine(result);
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}")

Warum löst mein Rückruf der String. Format-Methode eine FormatException aus?Why does my call to the String.Format method throw a FormatException?

Die häufigste Ursache für die Ausnahme ist, dass der Index eines Format Elements keinem Objekt in der Format Liste entspricht.The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. Normalerweise ist dies ein Hinweis darauf, dass Sie die Indizes von Format Elementen falsch nummeriert haben oder dass Sie vergessen haben, ein Objekt in die Format Liste einzufügen.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. Wenn Sie versuchen, eine Zeichenfolge mit Escapezeichen ohne Escapezeichen einzufügen, wird auch eine FormatExceptionausgelöst.Attempting to include an unescaped left or right brace character also throws a FormatException. Gelegentlich ist die Ausnahme das Ergebnis eines Typo. ein typischer Fehler ist beispielsweise, "[" (die linke Klammer) anstelle von "{" (der linken geschweiften Klammer) zu täuschen.Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).

Wenn das Format (System. IFormatProvider, System. String, System. Object [])-Methode Parameter Arrays unterstützt, löst mein Code eine Ausnahme aus, wenn ich ein Array verwende?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?

Der folgende Code löst z. b. eine FormatException Ausnahme aus:For example, the following code throws a FormatException exception:

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);   
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers)   
   End Sub
End Module

Dies ist ein Problem bei der Auflösung von compilerüberladungen.This is a problem of compiler overload resolution. Da der Compiler ein Array von ganzen Zahlen nicht in ein Objekt Array konvertieren kann, wird das ganzzahlige Array als einzelnes Argument behandelt, sodass die Format(String, Object)-Methode aufgerufen wird.Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. Die-Ausnahme wird ausgelöst, weil vier Format Elemente vorhanden sind, aber nur ein einzelnes Element in der Format Liste.The exception is thrown because there are four format items but only a single item in the format list.

Da weder Visual Basic noch C# ein ganzzahliges Array in ein Objekt Array konvertiert werden kann, müssen Sie die Konvertierung selbst durchführen, bevor Sie die Format(String, Object[])-Methode aufrufen.Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. Im folgenden Beispiel wird eine-Implementierung bereitstellt.The following example provides one implementation.

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);   
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Dim values(numbers.Length - 1) As Object
      numbers.CopyTo(values, 0) 
      Console.WriteLine("{0} + {1} + {2} = {3}", values)   
   End Sub
End Module

Format(String, Object)

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.Replaces one or more format items in a string with the string representation of a specified object.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String

Parameter

arg0
Object

Das zu formatierende Objekt.The object to format.

Gibt zurück

Eine Kopie von format, in der alle Formatelemente durch die Zeichenfolgendarstellung von arg0 ersetzt wurden.A copy of format in which any format items are replaced by the string representation of arg0.

Ausnahmen

format ist null.format is null.

Das Formatelement in format ist ungültig.The format item in format is invalid.

- oder --or- Der Index eines Formatelements ist nicht 0 (null).The index of a format item is not zero.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um den Wert eines Ausdrucks in seine Zeichen folgen Darstellung zu konvertieren und diese Darstellung in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält.Instead, you can call the method with a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Beispiel: Formatieren eines einzelnen ArgumentsExample: Formatting a single argument

Im folgenden Beispiel wird die Format(String, Object)-Methode verwendet, um das Alter einer Person in der Mitte einer Zeichenfolge einzubetten.The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.

using namespace System;

void main()
{
   DateTime birthdate = DateTime(1993, 7, 28);
   array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16), 
                                                    DateTime(1994, 7, 28), 
                                                    DateTime(2000, 10, 16), 
                                                    DateTime(2003, 7, 27), 
                                                    DateTime(2007, 5, 27) };

   for each (DateTime dateValue in dates)
   {
      TimeSpan interval = dateValue - birthdate;
      // Get the approximate number of years, without accounting for leap years.
      int years = ((int)interval.TotalDays) / 365;
      // See if adding the number of years exceeds dateValue.
      String^ output;
      if (birthdate.AddYears(years) <= dateValue) {
         output = String::Format("You are now {0} years old.", years);
         Console::WriteLine(output);
      }   
      else {
         output = String::Format("You are now {0} years old.", years - 1);
         Console::WriteLine(output);
      }      
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16), 
                     new DateTime(1994, 7, 28), 
                     new DateTime(2000, 10, 16), 
                     new DateTime(2003, 7, 27), 
                     new DateTime(2007, 5, 27) };

foreach (DateTime dateValue in dates)
{
   TimeSpan interval = dateValue - birthdate;
   // Get the approximate number of years, without accounting for leap years.
   int years = ((int) interval.TotalDays) / 365;
   // See if adding the number of years exceeds dateValue.
   string output;
   if (birthdate.AddYears(years) <= dateValue) {
      output = String.Format("You are now {0} years old.", years);
      Console.WriteLine(output);
   }   
   else {
      output = String.Format("You are now {0} years old.", years - 1);
      Console.WriteLine(output);
   }      
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
Module Example
   Public Sub Main()
      Dim birthdate As Date = #7/28/1993#
      Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
                              #7/27/2003#, #5/27/2007# }
      For Each dateValue As Date In dates
         Dim interval As TimeSpan = dateValue - birthdate
         ' Get the approximate number of years, without accounting for leap years.
         Dim years As Integer = CInt(interval.TotalDays) \ 365
         ' See if adding the number of years exceeds dateValue.
         Dim output As String
         If birthdate.AddYears(years) <= dateValue Then
            output = String.Format("You are now {0} years old.", years)
            Console.WriteLine(output)
         Else
            output = String.Format("You are now {0} years old.", years - 1)
            Console.WriteLine(output)   
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       You are now 0 years old.
'       You are now 1 years old.
'       You are now 7 years old.
'       You are now 9 years old.
'       You are now 13 years old.

Siehe auch

Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String

Parameter

args
Object[]

Ein Objektarray mit 0 (null) oder mehr zu formatierenden Objekten.An object array that contains zero or more objects to format.

Gibt zurück

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Objekte in args ersetzt wurden.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Ausnahmen

format oder args ist null.format or args is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des args-Arrays.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um den Wert von vier oder mehr Ausdrücken in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. Da der args-Parameter mit dem System.ParamArrayAttribute-Attribut markiert ist, können Sie die Objekte als einzelne Argumente oder als Object Array an die Methode übergeben.Since the args parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält.Instead, you can call the method with a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Beispiel: Formatieren von mehr als drei ArgumentenExample: Formatting more than three arguments

In diesem Beispiel wird eine Zeichenfolge erstellt, die Daten für die hohe und niedrige Temperatur an einem bestimmten Datum enthält.This example creates a string that contains data on the high and low temperature on a particular date. Die kombinierte Format Zeichenfolge enthält fünf Format Elemente C# im Beispiel und sechs im Visual Basic Beispiel.The composite format string has five format items in the C# example and six in the Visual Basic example. Zwei der Format Elemente definieren die Breite der Zeichen folgen Darstellung Ihres entsprechenden Werts, und das erste Format Element enthält auch eine Standardformat Zeichenfolge für Datum und Uhrzeit.Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.

using namespace System;

void main()
{
   DateTime date1 = DateTime(2009, 7, 1);
   TimeSpan hiTime = TimeSpan(14, 17, 32);
   Decimal hiTemp = (Decimal) 62.1; 
   TimeSpan loTime = TimeSpan(3, 16, 10);
   Decimal loTemp = (Decimal)54.8; 

   String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    date1, hiTime, hiTemp, loTime, loTemp);
   Console::WriteLine(result1);
   Console::WriteLine();
           
   String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
   Console::WriteLine(result2);
}
// The example displays the following output:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m; 
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m; 

string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
     
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
Module Example
   Public Sub Main()
      Dim date1 As Date = #7/1/2009#
      Dim hiTime As New TimeSpan(14, 17, 32)
      Dim hiTemp As Decimal = 62.1d 
      Dim loTime As New TimeSpan(3, 16, 10)
      Dim loTemp As Decimal = 54.8d 

      Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                           date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
      Console.WriteLine(result1)
      Console.WriteLine()
           
      Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                            New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
      Console.WriteLine(result2)                                            
   End Sub
End Module
' The example displays the following output:
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)
'
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)

Sie können die zu formatierenden Objekte auch als Array und nicht als Argumentliste übergeben.You can also pass the objects to be formatted as an array rather than as an argument list.

using namespace System;

ref class CityInfo
{
public:
   CityInfo(String^ name, int population, Decimal area, int year)
   {
      this->Name = name;
      this->Population = population;
      this->Area = area;
      this->Year = year;
   }
   
   String^ Name; 
   int Population;
   Decimal Area;
   int Year;
};

ref class Example
{
public:
   static void ShowPopulationData(CityInfo^ city)
   {
      array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
      String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console::WriteLine(result); 
   }
};

void main()
{
   CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
   Example::ShowPopulationData(nyc2010);
   CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);      
   Example::ShowPopulationData(sea2010); 
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;

public class CityInfo
{
   public CityInfo(String name, int population, Decimal area, int year)
   {
      this.Name = name;
      this.Population = population;
      this.Area = area;
      this.Year = year;
   }
   
   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class Example
{
   public static void Main()
   {
      CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
      ShowPopulationData(nyc2010);
      CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);      
      ShowPopulationData(sea2010); 
   }

   private static void ShowPopulationData(CityInfo city)
   {
      object[] args = { city.Name, city.Year, city.Population, city.Area };
      String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console.WriteLine(result); 
   }
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
   Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
      Me.Name = name
      Me.Population = population
      Me.Area = area
      Me.Year = year
   End Sub
   
   Public ReadOnly Name As String
   Public ReadOnly Population As Integer
   Public ReadOnly Area As Decimal
   Public ReadOnly Year As Integer
End Class

Module Example
   Public Sub Main()
      Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
      ShowPopulationData(nyc2010)
      Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)      
      ShowPopulationData(sea2010) 
   End Sub
   
   Private Sub ShowPopulationData(city As CityInfo)
      Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
      Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
      Console.WriteLine(result) 
   End Sub
End Module
' The example displays the following output:
'       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
'       Seattle in 2010: Population 608,660, Area 83.9 sq. feet   

Siehe auch

Format(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts.Replaces the format item or items in a specified string with the string representation of the corresponding object. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
static member Format : IFormatProvider * string * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.

arg0
Object

Das zu formatierende Objekt.The object to format.

Gibt zurück

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung von arg0 ersetzt wurden.A copy of format in which the format item or items have been replaced by the string representation of arg0.

Ausnahmen

format ist null.format is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist nicht 0 (null).The index of a format item is not zero.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um den Wert eines Ausdrucks in seine Zeichen folgen Darstellung zu konvertieren und diese Darstellung in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. Beim Durchführen der Konvertierung verwendet die-Methode Kultur abhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die-Methode konvertiert arg0 in ihre Zeichen folgen Darstellung, indem die ToString (IFormatProvider) -Methode aufgerufen wird, oder, wenn das entsprechende Format Element des Objekts eine Format Zeichenfolge enthält, indem die ToString (String, IFormatProvider) -Methode aufgerufen wird.The method converts arg0 to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Wenn diese Methoden nicht vorhanden sind, wird die Parameter lose- Methode des-Objekts aufgerufen.If these methods don't exist, it calls the object's parameterless ToString method.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie auch die Methode mit einem Objekt aufrufen, das kulturabhängige oder benutzerdefinierte Formatierungen sowie eine kombinierte Formatzeichenfolge bereitstellt, die mindestens ein Formatelement enthält.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.

args
Object[]

Ein Objektarray mit 0 (null) oder mehr zu formatierenden Objekten.An object array that contains zero or more objects to format.

Gibt zurück

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Objekte in args ersetzt wurden.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Ausnahmen

format oder args ist null.format or args is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des args-Arrays.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um vier oder mehr Ausdrücke in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. Beim Durchführen der Konvertierung verwendet die-Methode Kultur abhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die-Methode konvertiert jedes Object Argument in seine Zeichen folgen Darstellung, indem die ToString (IFormatProvider) -Methode aufgerufen wird, oder, wenn das entsprechende Format Element des Objekts eine Format Zeichenfolge enthält, indem dessen ToString (String, IFormatProvider) aufgerufen wird. -Methode.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Wenn diese Methoden nicht vorhanden sind, wird die Parameter lose- Methode des-Objekts aufgerufen.If these methods don't exist, it calls the object's parameterless ToString method.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie auch die Methode mit einem Objekt aufrufen, das kulturabhängige oder benutzerdefinierte Formatierungen sowie eine kombinierte Formatzeichenfolge bereitstellt, die mindestens ein Formatelement enthält.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Beispiel: Kultur abhängige FormatierungExample: Culture-sensitive formatting

In diesem Beispiel wird die Format(IFormatProvider, String, Object[])-Methode verwendet, um die Zeichen folgen Darstellung einiger Datums-und Uhrzeitwerte und numerischer Werte mithilfe verschiedener Kulturen anzuzeigen.This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.

string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };

DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
double value = 9164.32;

Console.WriteLine("Culture     Date                                Value\n");
foreach (string cultureName in cultureNames)
{
   System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(cultureName);
   string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", 
                                 culture.Name, dateToDisplay, value);
   Console.WriteLine(output);
}    
// The example displays the following output:
//    Culture     Date                                Value
//    
//    en-US       Tuesday, September 01, 2009         9,164.32
//    fr-FR       mardi 1 septembre 2009              9 164,32
//    de-DE       Dienstag, 1. September 2009         9.164,32
//    es-ES       martes, 01 de septiembre de 2009    9.164,32
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
      
      Dim dateToDisplay As Date = #9/1/2009 6:32PM#
      Dim value As Double = 9164.32

      Console.WriteLine("Culture     Date                                Value")
      Console.WriteLine()      
      For Each cultureName As String In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
                                              culture.Name, dateToDisplay, value)
         Console.WriteLine(output)
      Next    
   End Sub
End Module
' The example displays the following output:
'       Culture     Date                                Value
'       
'       en-US       Tuesday, September 01, 2009         9,164.32
'       fr-FR       mardi 1 septembre 2009              9 164,32
'       de-DE       Dienstag, 1. September 2009         9.164,32
'       es-ES       martes, 01 de septiembre de 2009    9.164,32

Siehe auch

Format(String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.Replaces the format items in a string with the string representation of two specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

Parameter

arg0
Object

Das erste zu formatierende Objekt.The first object to format.

arg1
Object

Das zweite zu formatierende Objekt.The second object to format.

Gibt zurück

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0 und arg1 ersetzt wurden.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Ausnahmen

format ist null.format is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist nicht 0 (null) oder 1.The index of a format item is not zero or one.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um den Wert von zwei Ausdrücken in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält.Instead, you can call the method with a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Beispiel: Formatieren von zwei ArgumentenExample: Formatting two arguments

In diesem Beispiel wird die Format(String, Object, Object)-Methode verwendet, um in einem generischen Dictionary<TKey,TValue>-Objekt gespeicherte Zeit-und Temperaturdaten anzuzeigen.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. Beachten Sie, dass die Format Zeichenfolge drei Format Elemente enthält, obwohl nur zwei zu formatierende Objekte vorhanden sind.Note that the format string has three format items, although there are only two objects to format. Dies liegt daran, dass das erste Objekt in der Liste (ein Datums-und Uhrzeitwert) von zwei Format Elementen verwendet wird: das erste Format Element zeigt die Uhrzeit an, während die zweite das Datum anzeigt.This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the date.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
   Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>(); 
   temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
   temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
   Console::WriteLine("Temperature Information:\n");
   String^ output;   
   for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
   {
      output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F", 
                              item->Key, item->Value);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5�F
//       Temperature at 10:00 AM on 12/1/2010:  36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

Console.WriteLine("Temperature Information:\n");
string output;   
foreach (var item in temperatureInfo)
{
   output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                          item.Key, item.Value);
   Console.WriteLine(output);
}
// The example displays output like the following:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5°F
//       Temperature at 10:00 AM on 12/1/2010:  36.8°F
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim temperatureInfo As New Dictionary(Of Date, Double) 
      temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
      temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
      
      Console.WriteLine("Temperature Information:")
      Console.WriteLine()
      Dim output As String   
      For Each item In temperatureInfo
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
                                item.Key, item.Value)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'       Temperature Information:
'       
'       Temperature at  2:00 PM on  6/1/2010:  87.5°F
'       Temperature at 10:00 AM on 12/1/2010:  36.8°F

Siehe auch

Format(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.Replaces the format items in a string with the string representation of two specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.

arg0
Object

Das erste zu formatierende Objekt.The first object to format.

arg1
Object

Das zweite zu formatierende Objekt.The second object to format.

Gibt zurück

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0 und arg1 ersetzt wurden.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Ausnahmen

format ist null.format is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist nicht 0 (null) oder 1.The index of a format item is not zero or one.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um zwei Ausdrücke in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. Beim Durchführen der Konvertierung verwendet die-Methode Kultur abhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die-Methode konvertiert jedes Object Argument in seine Zeichen folgen Darstellung, indem die ToString (IFormatProvider) -Methode aufgerufen wird, oder, wenn das entsprechende Format Element des Objekts eine Format Zeichenfolge enthält, indem dessen ToString (String, IFormatProvider) aufgerufen wird. -Methode.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Wenn diese Methoden nicht vorhanden sind, wird die Parameter lose- Methode des-Objekts aufgerufen.If these methods don't exist, it calls the object's parameterless ToString method.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie auch die Methode mit einem Objekt aufrufen, das kulturabhängige oder benutzerdefinierte Formatierungen sowie eine kombinierte Formatzeichenfolge bereitstellt, die mindestens ein Formatelement enthält.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.Replaces the format items in a string with the string representation of three specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parameter

arg0
Object

Das erste zu formatierende Objekt.The first object to format.

arg1
Object

Das zweite zu formatierende Objekt.The second object to format.

arg2
Object

Das dritte zu formatierende Objekt.The third object to format.

Gibt zurück

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0, arg1 und arg2 ersetzt wurden.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Ausnahmen

format ist null.format is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist kleiner als 0 (null) oder größer als 2.The index of a format item is less than zero, or greater than two.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um den Wert von drei Ausdrücken in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält.Instead, you can call the method with a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Beispiel: Formatieren von drei ArgumentenExample: Formatting three arguments

In diesem Beispiel wird die Format(String, Object, Object, Object)-Methode verwendet, um eine Zeichenfolge zu erstellen, die das Ergebnis einer booleschen And Operation mit zwei ganzzahligen Werten veranschaulicht.This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And operation with two integer values. Beachten Sie, dass die Format Zeichenfolge sechs Format Elemente enthält, die-Methode jedoch nur drei Elemente in der Parameterliste aufweist, da jedes Element auf zwei verschiedene Arten formatiert ist.Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.

using namespace System;

void main()
{
   String^ formatString = "    {0,10} ({0,8:X8})\n" + 
                           "And {1,10} ({1,8:X8})\n" + 
                           "  = {2,10} ({2,8:X8})";
   int value1 = 16932;
   int value2 = 15421;
   String^ result = String::Format(formatString, 
                                   value1, value2, value1 & value2);
   Console::WriteLine(result);
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
string formatString = "    {0,10} ({0,8:X8})\n" + 
                      "And {1,10} ({1,8:X8})\n" + 
                      "  = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString, 
                              value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
Public Module Example
   Public Sub Main()
      Dim formatString As String = "    {0,10} ({0,8:X8})" + vbCrLf +  _
                                   "And {1,10} ({1,8:X8})" + vbCrLf + _
                                   "  = {2,10} ({2,8:X8})"
      Dim value1 As Integer = 16932
      Dim value2 As Integer = 15421
      Dim result As String = String.Format(formatString, _
                                           value1, value2, value1 And value2)
      Console.WriteLine(result)                          
   End Sub
End Module
' The example displays the following output:
'                16932 (00004224)
'       And      15421 (00003C3D)
'         =         36 (00000024)

Siehe auch

Format(IFormatProvider, String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.Replaces the format items in a string with the string representation of three specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen.An parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.

arg0
Object

Das erste zu formatierende Objekt.The first object to format.

arg1
Object

Das zweite zu formatierende Objekt.The second object to format.

arg2
Object

Das dritte zu formatierende Objekt.The third object to format.

Gibt zurück

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0, arg1 und arg2 ersetzt wurden.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Ausnahmen

format ist null.format is null.

format ist ungültig.format is invalid.

- oder --or- Der Index eines Formatelements ist kleiner als 0 (null) oder größer als 2.The index of a format item is less than zero, or greater than two.

Hinweise

Wichtig

Statt die Methode String.Format aufzurufen oder Zeichenfolgen mit kombinierter Formatierung zu verwenden, können Sie interpolierte Zeichenfolgen verwenden, wenn diese von Ihrer Sprache unterstützt werden.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports 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).

Diese Methode verwendet die Funktion für die kombinierte Formatierung , um drei Ausdrücke in ihre Zeichen folgen Darstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. Beim Durchführen der Konvertierung verwendet die-Methode Kultur abhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die-Methode konvertiert jedes Object Argument in seine Zeichen folgen Darstellung, indem die ToString (IFormatProvider) -Methode aufgerufen wird, oder, wenn das entsprechende Format Element des Objekts eine Format Zeichenfolge enthält, indem dessen ToString (String, IFormatProvider) aufgerufen wird. -Methode.The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Wenn diese Methoden nicht vorhanden sind, wird die Parameter lose- Methode des-Objekts aufgerufen.If these methods don't exist, it calls the object's parameterless ToString method.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Stattdessen können Sie auch die Methode mit einem Objekt aufrufen, das kulturabhängige oder benutzerdefinierte Formatierungen sowie eine kombinierte Formatzeichenfolge bereitstellt, die mindestens ein Formatelement enthält.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null).You assign each format item a numeric index; the first index starts at 0. Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen.In addition to the initial string, your method call should have as many additional arguments as it has index values. Beispielsweise sollte eine Zeichenfolge, deren Formatelemente die Indizes 0 und 1 aufweisen, über zwei Argumente verfügen. Dabei sollte ein Argument über bis zu fünf Indizes und eins über sechs Argumente verfügen.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Weitere Informationen zur String.Format-Methode finden Sie unter Getting started with the String.Format method (Erste Schritte mit der String.Format-Methode) und Which method do I call? (Welche Methode soll ich aufrufen?).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Gilt für: