String.Format String.Format String.Format String.Format Method

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(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) 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.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) 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) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) 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) Format(String, Object, Object) Format(String, Object, Object) 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[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) 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(String, Object[]) Format(String, Object[]) Format(String, 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(String, Object) Format(String, Object) Format(String, Object) 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.

Beispiele

Zahlreiche Beispiele, die aufgerufen werden die Format Methode vermischt werden, über die "Hinweise" Abschnitt dieses Artikels.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.The C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.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 vollständigen Satz von String.Format Beispiele, die enthalten sind ein .NET Core 2.0-Projekt für C#-Code und .NET Core 2.0-Projekt für Visual Basic, aus der Dotnet / GitHub-beispielrepository.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 werden einige der Beispiele in diesem Artikel enthalten:The following are some of the examples included in the article:

Erstellen Sie eine FormatzeichenfolgeCreate a format string

Eine Zeichenfolge eingefügtInserting a string
Das FormatelementThe format item
Formatelemente, die den gleichen Index aufweisen.Format items that have the same index

Steuern Sie formatierten AusgabeControl formatted output

Steuern der FormatierungControlling formatting
Steuern der AbstandControlling spacing
Steuern der AusrichtungControlling alignment
Steuern der Anzahl von ganzzahligen ZiffernControlling the number of integral digits
Steuern die Anzahl der Ziffern nach dem DezimaltrennzeichenControlling the number of digits after the decimal separator
Literale geschweifte Klammern einschließlich in eine ErgebniszeichenfolgeIncluding literal braces in a result string

Stellen Sie Formatzeichenfolgen kulturabhängigeMake format strings culture-sensitive

Kulturabhängige FormatierungCulture-sensitive formatting

Anpassen des FormatierungsvorgangsCustomize the formatting operation

Einen benutzerdefinierten FormatierungsvorgangA custom formatting operation
Eine Konstante Glied-Anbieter und die römische Zahl FormatierungsprogrammAn 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:

Erste Schritte mit der String.Format-Methode Get started with the String.Format method
Welche Methode rufe ich? Which method do I call?
Der Format-Methode in Kürze The Format method in brief
Das Format-Element The Format item
Wie werden Argumente formatiert. How arguments are formatted
Formatelemente, die den gleichen Index aufweisen. Format items that have the same index
Formatierung und Kultur Formatting and culture
Benutzerdefinierte Formatierung Vorgänge Custom formatting operations
"String.Format"-F & AString.Format Q & A

Erste Schritte mit der String.Format-MethodeGet started with the String.Format method

Verwendung String.Format Wenn Sie den Wert eines Objekts, eine Variable oder ein Ausdruck in einer anderen Zeichenfolge einzufügen müssen.Use String.Format if you need to insert the value of an object, variable, or expression into another string. Sie können beispielsweise den Wert der Einfügen einer Decimal Wert in eine Zeichenfolge für den Benutzer als einzelne Zeichenfolge angezeigt: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 des 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 Abstände steuern.Besides formatting, you can also control alignment and spacing.

Eine Zeichenfolge eingefügtInserting a string

String.Format beginnt mit einer Formatzeichenfolge, gefolgt von ein oder mehrere Objekte oder Ausdrücke, die in Zeichenfolgen konvertiert und an einer angegebenen Position in der Formatzeichenfolge 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. Zum 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.'

Die {0} im Format Zeichenfolge eines Formatelements ist.The {0} in the format string is a format item. 0 ist der Index des Objekts, dessen 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 Objekt eingefügt werden soll, keine Zeichenfolge, ist die ToString Methode wird aufgerufen, um sie zu einem vor dem Einfügen in der Ergebniszeichenfolge zu konvertieren.(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.

Hier ist ein weiteres Beispiel, das zwei Formatelemente und zwei Objekte in der Objektliste verwendet: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 Formatelemente und beliebig viele Objekte in der Objektliste, wie Sie möchten, solange der Index der jedes Formatelement, das kein übereinstimmendes 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. Ferner müssen nicht Gedanken machen, über welche, die Überladung Sie aufrufen; der Compiler wird das entsprechende Feld für die Sie auswählen.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

Führen Sie den Index in einem Formatelement, das mit einer Formatzeichenfolge zu steuern, wie ein Objekt formatiert ist.You can follow the index in a format item with a format string to control how an object is formatted. Z. B. {0:d} gilt die Zeichenfolge "d" zum ersten Objekt in der Objektliste.For example, {0:d} applies the "d" format string to the first object in the object list. Es folgt ein Beispiel mit einem einzelnen Objekt und zwei Elemente formatieren: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 Anzahl von Typen unterstützen Formatzeichenfolgen, einschließlich aller numerischen Typen (sowohl standard und benutzerdefinierte Formatzeichenfolgen), alle Datums- und Uhrzeitangaben (beide standard und benutzerdefinierte Formatzeichenfolgen) und Zeitintervalle (beide standard und benutzerdefinierte Formatzeichenfolgen), alle Enumerationstypen Enumerationstypen , und 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 Formatzeichenfolgen für eigene Typen hinzufügen.You can also add support for format strings to your own types.

Steuern der AbstandControlling spacing

Sie können die Breite der Zeichenfolge, die in die Ergebniszeichenfolge eingefügt wird, wie z. B. mit der Syntax definieren {0,12}, die eine 12 Zeichen bestehende Zeichenfolge eingefü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 ist die Zeichenfolgendarstellung des ersten Objekts rechtsbündig in das Feld 12 Zeichen bestehende.In this case, the string representation of the first object is right-aligned in the 12-character field. (Wenn die Zeichenfolgendarstellung des ersten Objekts mehr als 12 Zeichen lang ist, jedoch die gewünschte Feldbreite wird ignoriert, und die gesamte Zeichenfolge wird in die Ergebniszeichenfolge 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.)

Das folgende Beispiel definiert ein Feld 6 Zeichen, um die Zeichenfolge "Year" und einige Zeichenfolgen von Jahr, als auch ein Feld 15 Zeichen für die Zeichenfolge "Auffüllung" und einige Daten auffüllen.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 das Feld.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
using System;
using System.Text;
 
class Example
{
   public static void Main()
   {
       // <Snippet33>
       int[] years = { 2013, 2014, 2015 };
       int[] population = { 1025632, 1105967, 1148203 };
       var sb = new 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 Zeichenfolgen in ihre Feld rechtsbündig ausgerichtet, wenn Sie eine Feldbreite angeben.By default, strings are right-aligned within their field if you specify a field width. Um Zeichenfolgen in einem Feld linksbündig, Sie stellen die Feldbreite ein negatives Vorzeichen, z. B. {0,-12} so definieren Sie ein Feld mit 12 Zeichen bestehende linksbündig ausgerichtet.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.

Im folgende Beispiel ähnelt dem vorherigen Beispiel, außer dass sie sowohl die Bezeichnungen als auch die Daten linksbündig.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 der Funktion für kombinierte Formatierung verwendet.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?Which method do I call?

BeschreibungTo CallCall
Ein oder mehrere Objekte mit den Konventionen der aktuellen Kultur zu formatieren.Format one or more objects by using the conventions of the current culture. Mit Ausnahme der Überladungen, die eine provider Parameter, die verbleibenden Format -Überladungen enthalten eine String Parameter folgen eine oder mehrere Objektparameter.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, die Sie aufrufen möchten.Because of this, you don't have to determine which Format overload you intend to call. Ihr Sprachcompiler wählt die entsprechende Überladung zwischen Überladungen, die keinem provider basierend auf Ihrer Typargumentliste-Parameter.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Z. B. Wenn Sie Ihrer Typargumentliste fünf Argumente verfügt, die der Compiler Ruft die Format(String, Object[]) Methode.For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Ein oder mehrere Objekte mit den Konventionen einer bestimmten Kultur zu formatieren.Format one or more objects by using the conventions of a specific culture. Jede Format Überladung, die mit beginnt eine provider -Parameter folgt einem String Parameter und mindestens eine 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 nicht haben festlegen, um zu bestimmen, welche spezifischen Format Überladung, die Sie aufrufen möchten.Because of this, you don't have to determine which specific Format overload you intend to call. Ihr Sprachcompiler wählt die entsprechende Überladung aus die Überladungen mit einem provider basierend auf Ihrer Typargumentliste-Parameter.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Z. B. Wenn Sie Ihrer Typargumentliste fünf Argumente verfügt, die der Compiler Ruft die Format(IFormatProvider, String, Object[]) Methode.For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Führen Sie einem benutzerdefinierten Formatierungsvorgang entweder mit einem ICustomFormatter Implementierung oder IFormattable Implementierung.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. Die vier Überladungen mit einem provider Parameter.Any of the four overloads with a provider parameter. Der Compiler wählt die entsprechende Überladung aus die Überladungen mit einem provider basierend auf Ihrer Typargumentliste-Parameter.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Der Format-Methode in KürzeThe Format method in brief

Jede Überladung der der Format -Methode verwendet die Funktion für kombinierte Formatierung nullbasierte indizierte Platzhaltern, so genannten einschließen Elemente formatieren, in eine kombinierte Formatzeichenfolge.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 Formatelement durch die Zeichenfolgendarstellung 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 null, ersetzt das Formatelement mit String.Empty.If the value of the argument is null, the format item is replaced with String.Empty. Beispielsweise der folgende Aufruf von der Format(String, Object, Object, Object) Methode enthält eine Formatzeichenfolge mit drei Formatelemente {0}, {1}, und {2}, und einer 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 FormatelementThe format item

Ein Formatelement, das hat folgende Syntax:A format item has this syntax:

{index[,alignment][:formatString]}  

Klammern bezeichnen optionale Elemente.Brackets denote optional elements. Die öffnende und schließende geschweifte Klammern sind erforderlich.The opening and closing braces are required. (Umfassen eine literale öffnende oder schließende geschweifte Klammer in der Formatzeichenfolge der versehen von geschweiften Klammern im Abschnitt der kombinierte Formatierung Artikel.)(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Beispielsweise kann ein Formatelement, das einen Währungswert formatiert Folgendes angezeigt: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)        

Einem Formatelement hat die folgenden Elemente:A format item has the following elements:

indexindex
Der nullbasierte Index des Arguments, dessen Zeichenfolgendarstellung werden an dieser Position in der Zeichenfolge enthalten.The zero-based index of the argument whose string representation is to be included at this position in the string. Wenn dieses Argument null, eine leere Zeichenfolge wird an dieser Position in der Zeichenfolge enthalten sein.If this argument is null, an empty string will be included at this position in the string.

Ausrichtungalignment
Dies ist optional.Optional. Eine Ganzzahl mit Vorzeichen gibt an, dass die Gesamtlänge des Felds in der eingefügt wird, dass Sie des Arguments und gibt an, ob rechts ausgerichtet wird (eine positive ganze Zahl) oder linksbündig ausgerichtet (eine negative ganze Zahl).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 weglassen Ausrichtung, die Zeichenfolgendarstellung des entsprechenden Arguments in einem Feld darf keine führenden oder nachgestellten Leerzeichen eingefügt wird.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 des Ausrichtung ist kleiner als die Länge des Arguments, eingefügt werden soll, Ausrichtung wird ignoriert, und die Länge der Zeichenfolgendarstellung 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 Ergebniszeichenfolge für das entsprechende Argument angibt.A string that specifies the format of the corresponding argument's result string. Wenn Sie weglassen FormatString, das entsprechende Argument der parameterlosen ToString Methode wird aufgerufen, um die Zeichenfolgendarstellung zu erzeugen.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. Bei Angabe von FormatString, muss das Argument verwiesen wird, von dem Formatelement, das Implementieren der IFormattable Schnittstelle.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. Typen, die Formatzeichenfolgen unterstützen umfassen:Types that support format strings include:

Beachten Sie jedoch, dass für jeden benutzerdefinierter Typ implementieren, kann IFormattable oder Erweitern eines vorhandenen Typs IFormattable Implementierung.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

Im folgenden Beispiel wird die alignment und formatString Argumente, die formatierte Ausgabe erzeugen.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 %
using System;

public class Example
{
   public static void Main()
   {
      // 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 %

Wie werden Argumente formatiert.How arguments are formatted

Formatelemente werden nacheinander vom Anfang der Zeichenfolge verarbeitet.Format items are processed sequentially from the beginning of the string. Jedes Formatelement verfügt über einen Index, der auf ein Objekt in der Methode Argumentliste entspricht.Each format item has an index that corresponds to an object in the method's argument list. Die Format Methode ruft das Argument und seine Zeichenfolgendarstellung wie folgt abgeleitet:The Format method retrieves the argument and derives its string representation as follows:

Ein Beispiel für die fängt Aufrufe an die ICustomFormatter.Format Methode und ermöglicht Ihnen, welche Informationen finden Sie unter der Format -Methode übergibt, einer Formatierungsmethode für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge, finden Sie unter Beispiel: ein Anbieter abfangen und Römische Ziffer Formatierungsprogramm.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 unter den Verarbeitungsreihenfolge im Abschnitt der kombinierte Formatierung Artikel.For more information, see the Processing Order section in the Composite Formatting article.

Formatelemente, die den gleichen Index aufweisen.Format items that have the same index

Die Format -Methode löst eine FormatException -Ausnahme aus, wenn der Index eines Elements der Index größer als oder gleich der Anzahl von Argumenten 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. Allerdings format zählen mehrere Formatelemente, die als Argumente vorhanden sind, als mehrere Formatelemente auf den gleichen Index aufweisen.However, format can include more format items than there are arguments, as long as multiple format items have the same index. Im Aufruf der Format(String, Object) -Methode in der folgenden Beispiel wird die Argumentliste verfügt über ein einzelnes Argument, aber die Formatzeichenfolge enthält zwei Formatelemente: eine zeigt den Dezimalwert einer Zahl und das andere seinem Hexadezimalwert.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.

public class Example
{
   public static void Main()
   {
      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 Objekte in der Argumentliste werden in konvertiert die zeichenfolgendarstellungen, die mithilfe der Konventionen der aktuellen Kultur, die von zurückgegeben wird das CultureInfo.CurrentCulture Eigenschaft.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 Überladungen der Format , umfasst eine provider Parameter.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. Die provider -Parameter ist ein IFormatProvider -Implementierung, die benutzerdefinierte und kulturspezifische Formatierungsinformationen bereitstellt, der verwendet wird, um die Formatierung Mittel zu verarbeiten.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, ist zuständig für die Rückgabe des Objekts, 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 bereitzustellen:.NET has three IFormatProvider implementations that provide culture-specific formatting:

Benutzerdefinierte Formatierung VorgängeCustom formatting operations

Sie können auch eine der Überladungen der Aufrufen der Format Methode, die eine provider Parameter vom Typ IFormatProvider zum Ausführen von Vorgängen für benutzerdefinierte Formatierung.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. Sie können z. B. eine ganze Zahl als eine ID oder eine Telefonnummer formatieren.For example, you could format an integer as an identification number or as a telephone number. Benutzerdefinierte Formatierung Ausführen Ihrer provider Argument muss beide implementieren die IFormatProvider und ICustomFormatter Schnittstellen.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. Bei der Format -Methode übergeben ein ICustomFormatter Implementierung als die provider -Argument, die Format Methodenaufrufe der IFormatProvider.GetFormat Implementierung und fordert ein Objekt vom Typ ICustomFormatter.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. Es ruft dann die zurückgegebene ICustomFormatter des Objekts Format Methode zum Formatieren der einzelnen Elemente in der zusammengesetzten Zeichenfolge übergeben.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 benutzerdefinierter Formatierung Lösungen finden Sie unter wie: definieren und benutzerdefinierten numerischen Formatanbietern verwenden 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: eine benutzerdefinierte Formatierungsvorgang.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Ein Beispiel, das Bytes ohne Vorzeichen in römischen Ziffern konvertiert werden, finden Sie unter Beispiel: eine Konstante Glied-Anbieter und die römische Zahl Formatierungsprogramm.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Beispiel: Eine benutzerdefinierte FormatierungsvorgangExample: A custom formatting operation

Dieses Beispiel definiert einen Formatanbieter, der einen ganzzahligen Wert als die Kontonummer eines Kunden 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: Eine Konstante Glied Anbieter und römische Ziffer FormatierungsprogrammExample: An intercept provider and Roman numeral formatter

Dieses Beispiel definiert einen benutzerdefiniertes Format-Anbieter, implementiert die ICustomFormatter und IFormatProvider Schnittstellen für zwei Dinge tun:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Es zeigt die Parameter, die an die ICustomFormatter.Format Implementierung.It displays the parameters passed to its ICustomFormatter.Format implementation. Dies ermöglicht uns, welche Parameter finden Sie unter den Format(IFormatProvider, String, Object[]) übergeben Methode ist für die benutzerdefinierte Formatierung Implementierung für jedes Objekt, das er versucht, zu formatieren.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 nützlich sein, wenn Sie Ihre Anwendung debuggen.This can be useful when you're debugging your application.

  • Wenn das Objekt zu formatierenden einen Bytewert ohne Vorzeichen, die mit der standardmäßigen Formatzeichenfolge "R" formatiert sein, formatiert das benutzerdefinierte Formatierungsprogramm den numerischen Wert als einer römischen Zahl.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"-F & AString.Format Q & A

Warum empfehlen Sie zeichenfolgeninterpolation über Aufrufe an die String.Format Methode?Why do you recommend string interpolation over calls to the String.Format method?

Zeichenfolgeninterpolation ist:String interpolation is:

  • Mehr Flexibilität.More flexible. Es kann eine beliebige Zeichenfolge ohne einen Aufruf einer Methode, die kombinierte Formatierung unterstützen verwendet werden.It can be used in any string without requiring a call to a method that supports composite formatting. Andernfalls muss der Format -Methode oder eine andere Methode, die kombinierte Formatierung, z. B. unterstützt Console.WriteLine oder StringBuilder.AppendFormat.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 zum Einfügen in eine Zeichenfolge in der interpolierte Ausdruck nicht in einer Argumentliste angezeigt wird, sind interpolierte Zeichenfolgen viel einfacher, Code 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 ihrer bessere Lesbarkeit interpolierte Zeichenfolgen können nicht nur Aufrufe von Methoden für zusammengesetzte ersetzen, aber sie können auch in zeichenfolgenverkettung verwendet werden, um präziseren Code klarer zu erzeugen.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 der Überlegenheit von interpolierten Zeichenfolgen verketten von Zeichenfolgen und Aufrufe von Methoden zur kombinierten Formatierung.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. Die Verwendung von mehreren zeichenfolgenverkettung im folgenden Beispiel erzeugt ausführliche und schwer lesbaren Code.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

using System;

public class Example
{
   public static void Main()
   {
      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 die Verwendung von interpolierte Zeichenfolgen im folgenden Beispiel erzeugen viel klarer Code präziser als die Zeichenfolge verketten-Anweisung und der Aufruf von der Format -Methode in der 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.

using System;

public class Example
{
   public static void Main()
   {
      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 Formatzeichenfolgen, die mit einem Formatelement verwendet werden können?Where can I find a list of the predefined format strings that can be used with format items?

Wie steuere ich die Ausrichtung des Ergebniszeichenfolgen, die Formatelemente ersetzen?How do I control the alignment of the result strings that replace format items?

Die allgemeine Syntax eines Formatelements ist:The general syntax of a format item is:

{index[,alignment][: formatString]}  

wo Ausrichtung ist eine Ganzzahl mit Vorzeichen, die die Breite des Felds definiert.where alignment is a signed integer that defines the field width. Wenn dieser Wert negativ ist, wird Text in das Feld linksbündig ausgerichtet.If this value is negative, text in the field is left-aligned. Wenn sie positiv ist, ist Text rechtsbündig ausgerichtet.If it is positive, text is right-aligned.

Wie steuere ich die Anzahl der Ziffern nach dem Dezimaltrennzeichen?How do I control the number of digits after the decimal separator?

Alle standardmäßige numerische Formatzeichenfolgen mit Ausnahme von "D" (die mit nur ganze Zahlen verwendet wird), "G", "R" und "X" ermöglichen ein Genauigkeitsbezeichner angegeben, die die Anzahl von Dezimalstellen in der Ergebniszeichenfolge 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 wird die standardmäßige numerische Formatzeichenfolgen, die Anzahl von Dezimalstellen in der Ergebniszeichenfolge steuern.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

using System;

public class Example
{
   public static void Main()
   {
      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 %

Bei Verwendung einer benutzerdefinierte numerische Formatzeichenfolge, den Formatbezeichner "0" zum Steuern der Anzahl von Dezimalstellen in der Ergebniszeichenfolge enthält, wie im folgenden Beispiel gezeigt verwenden.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.

using System;

public class Example
{
   public static void Main()
   {
      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

Wie steuere ich die Anzahl von ganzzahligen Ziffern?How do I control the number of integral digits?

Standardmäßig werden Formatierungsvorgängen nur ungleich NULL ganzzahlige Ziffern angezeigt.By default, formatting operations only display non-zero integral digits. Wenn Sie ganze Zahlen formatieren, können Sie ein Genauigkeitsbezeichner angegeben, mit der "D" und "X" standard verwendete Formatzeichenfolgen, zum Steuern der Anzahl von Ziffern.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.

using System;

public class Example
{
   public static void Main()
   {
      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

Können Sie eine ganze Zahl oder Gleitkommazahl mit führenden Nullen, um eine Ergebniszeichenfolge, die mit einer angegebenen Anzahl von ganzzahligen Ziffern zu erzeugen, mithilfe von "0" Auffüllen benutzerdefinierten numerischen Format Specifier, wie im folgende 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.

using System;

public class Example
{
   public static void Main()
   {
      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 der Formatliste aufnehmen?How many items can I include in the format list?

Es ist praktisch unbeschränkt.There is no practical limit. Der zweite Parameter von der Format(IFormatProvider, String, Object[]) Methode wird mit markiert die ParamArrayAttribute -Attribut, das Ihnen ermöglicht, die entweder eine durch Trennzeichen getrennte Liste oder ein Objektarray als Formatliste enthalten.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.

Wie beziehe ich ein literal geschweifte Klammern ("{" und "}") in der Ergebniszeichenfolge?How do I include literal braces ("{" and "}") in the result string?

Z. B. wie Sie verhindern, dass den folgende Methodenaufruf vom Auslösen einer FormatException Ausnahme?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 Formatelements interpretiert.A single opening or closing brace is always interpreted as the beginning or end of a format item. Um die interpretiert werden, muss er mit Escapezeichen versehen werden.To be interpreted literally, it must be escaped. Sie eine geschweifte Klammer durch Hinzufügen einer anderen geschweiften Klammern mit Escapezeichen versehen ("{{" und "}}" anstelle von "{" und "}"), wie in den folgenden Methodenaufruf: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)

Geschweifte Klammern selbst mit Escapezeichen gibt allerdings leicht falsch interpretiert.However, even escaped braces are easily misinterpreted. Es wird empfohlen, dass Sie die geschweiften Klammern, in der Formatliste einschließen und Formatelementen zum Einfügen in der Ergebniszeichenfolge enthält, wie im folgenden Beispiel gezeigt verwenden.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 wird meine Aufruf der Methode "String.Format" FormatException ausgelöst?Why does my call to the String.Format method throw a FormatException?

Die häufigste Ursache der Ausnahme ist, dass der Index eines Formatelements entspricht nicht auf ein Objekt in der Formatliste definiert.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. In der Regel bedeutet dies, Sie die Indizes der Formatelemente misnumbered haben oder Sie vergessen haben, ein Objekt in der Formatliste einfügen möchten.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. Es wird versucht, einen ohne Escapezeichen linke oder rechte Klammer Zeichen auch löst eine FormatException.Attempting to include an unescaped left or right brace character also throws a FormatException. In einigen Fällen ist die Ausnahme das Ergebnis war ein Tippfehler; ein typischer Fehler ist beispielsweise falsch eingeben "[" (die öffnende Klammer) anstelle von "{" (die linke geschweifte Klammer).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 die Methode Format(System.IFormatProvider,System.String,System.Object[]) Parameterarrays, warum mein Code eine Ausnahme auslöst unterstützt, wenn ich ein Array verwenden?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 beispielsweise löst ein FormatException Ausnahme:For example, the following code throws a FormatException exception:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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 der überladungsauflösung des Compiler.This is a problem of compiler overload resolution. Da der Compiler ein Array von Ganzzahlen in ein Objektarray konvertieren kann, es wird das ganze Zahl Array als ein einzelnes Argument, aufruft und es dem Format(String, Object) Methode.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, da es vier Formatelemente aber nur ein einzelnes Element in der Formatliste gibt.The exception is thrown because there are four format items but only a single item in the format list.

Da weder Visual Basic oder c# ein Array von Ganzzahlen in ein Objektarray konvertieren kann, haben Sie zum Durchführen der Konvertierung selbst vor dem Aufruf der Format(String, Object[]) Methode.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.The following example provides one implementation.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) 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 IFormatProvider IFormatProvider IFormatProvider

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

arg0
Object Object Object Object

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

arg1
Object Object Object Object

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

arg2
Object Object Object Object

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

Gibt zurück

Eine Kopie von format, in der die 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 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 kombinierte Formatierung , drei Ausdrücke in ihre Zeichenfolgendarstellung 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, kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die Methode konvertiert jede Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider) Methode oder das Objekt entsprechende schließt Formatelement, das eine Formatzeichenfolge, durch Aufrufen der ToString(String,IFormatProvider) 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, ruft das Objekt die parameterlosen ToString Methode.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) Format(String, Object, Object, Object) Format(String, Object, Object, Object) 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 Object Object Object

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

arg1
Object Object Object Object

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

arg2
Object Object Object Object

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

Gibt zurück

Eine Kopie von format, in der die 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 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 kombinierte Formatierung um den Wert der drei Ausdrücke, deren Zeichenfolgenrepräsentationen 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

Dieses Beispiel verwendet die Format(String, Object, Object, Object) Methode, um eine Zeichenfolge zu erstellen, die das Ergebnis von booleschen Werten veranschaulicht And Vorgang mit zwei ganzzahligen Werten.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 Formatzeichenfolge sechs Formatelemente enthält, aber die Methode nur drei Elemente in der Parameterliste hat, 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)
using System;

public class Example
{
   public static 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)
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) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) 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 IFormatProvider IFormatProvider IFormatProvider

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

arg0
Object Object Object Object

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

arg1
Object Object Object 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 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 kombinierte Formatierung , zwei Ausdrücke in ihre Zeichenfolgendarstellung 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, kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die Methode konvertiert jede Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider) Methode oder das Objekt entsprechende schließt Formatelement, das eine Formatzeichenfolge, durch Aufrufen der ToString(String,IFormatProvider) 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, ruft das Objekt die parameterlosen ToString Methode.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) Format(String, Object, Object) Format(String, Object, Object) 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 Object Object Object

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

arg1
Object Object Object 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 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 kombinierte Formatierung , den Wert von zwei Ausdrücken, deren Zeichenfolgenrepräsentationen 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

Dieses Beispiel verwendet die Format(String, Object, Object) anzuzeigenden Zeit und Temperatur-Daten in einer generischen Methode Dictionary<TKey,TValue> Objekt.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 Zeichenfolge drei Formatelemente, allerdings nur zwei stehen zu formatierenden Objekten.Note that the format string has three format items, although there are only two objects to format. Dies ist, weil das erste Objekt in der Liste (ein Wert für Datum und Uhrzeit) von zwei Formatelemente verwendet werden: die erste Format-Element angezeigt, die Zeit, und die zweite zeigt das Datum an.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
using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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 IFormatProvider IFormatProvider 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 kombinierte Formatierung , vier oder mehr Ausdrücke in ihre Zeichenfolgendarstellung 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, kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Die Methode konvertiert jede Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider) Methode oder das Objekt entsprechende schließt Formatelement, das eine Formatzeichenfolge, durch Aufrufen der ToString(String,IFormatProvider) 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, ruft das Objekt die parameterlosen ToString Methode.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: Kulturabhängige FormatierungExample: Culture-sensitive formatting

Dieses Beispiel verwendet die Format(IFormatProvider, String, Object[]) Methode, um die Zeichenfolgendarstellung für einige Datums-und Uhrzeitwerte und numerische Werte anzeigen, indem Sie verschiedene Kulturen verwenden.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.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      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)
      {
         CultureInfo culture = new 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(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) 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 IFormatProvider IFormatProvider IFormatProvider

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

arg0
Object Object Object 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 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 kombinierte Formatierung , den Wert eines Ausdrucks in seine Zeichenfolgendarstellung zu konvertieren und diese Darstellung in einer 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, kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Konvertiert die Methode arg0 in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider) Methode oder das Objekt entsprechende schließt Formatelement, das eine Formatzeichenfolge, durch den Aufruf der ToString () String, IFormatProvider) Methode.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, ruft das Objekt die parameterlosen ToString Methode.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[]) Format(String, Object[]) Format(String, 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.

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 kombinierte Formatierung , den Wert der vier oder mehr Ausdrücke, deren Zeichenfolgenrepräsentationen 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 die args Parameter markiert wird, mit der System.ParamArrayAttribute -Attribut, Sie können die Objekte an die Methode übergeben als einzelne Argumente oder als ein Object Array.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 ArgumenteExample: Formatting more than three arguments

Dieses Beispiel erstellt eine Zeichenfolge, die Daten für die Höchst- und Tiefsttemperatur für ein bestimmtes Datum enthält.This example creates a string that contains data on the high and low temperature on a particular date. Die zusammengesetzte Formatierungszeichenfolge verfügt über fünf Formatelemente in c#-Beispiel und sechs in Visual Basic-Beispiel.The composite format string has five format items in the C# example and six in the Visual Basic example. Zwei der die Formatelemente definieren die Breite des Werts, auf die entsprechende Zeichenfolgendarstellung und das erste Formatelement enthält auch einen Standardformatbezeichner für Datum und Uhrzeit-Formatzeichenfolge.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)
using System;

public class Example
{
   public static void Main()
   {
      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 auch übergeben der Objekte, die als Array formatiert werden anstelle eines Argumentliste enthalten.You can also pass the objects to be formatted as an array rather than a 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(String, Object) Format(String, Object) Format(String, Object) 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 Object Object 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

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 kombinierte Formatierung , den Wert eines Ausdrucks in seine Zeichenfolgendarstellung zu konvertieren und diese Darstellung in einer 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, um das Alter einer Einzelperson 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.
using System;

public class Example
{
   public static void Main()
   {
      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

Gilt für: