String.Format Methode

Definition

Konvertiert auf der Grundlage der angegebenen Formate den Wert von Objekten in Zeichenfolgen und fügt sie in eine andere Zeichenfolge ein.

Wenn Sie die String.Format-Methode noch nicht kennen, lesen Sie den Abschnitt zur String.Format-Methode, um sich einen Überblick zu verschaffen.

Eine allgemeine Dokumentation zur String.Format-Methode finden Sie im Abschnitt Hinweise.

Überlädt

Format(String, Object)

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.

Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.

Format(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.

Format(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Beispiele

Zahlreiche Beispiele, die die -Methode aufrufen, Format werden im Abschnitt "Hinweise" dieses Artikels durchsetzt.

Sie können auch einen vollständigen Satz von String.Format Beispielen herunterladen, die ein .NET Core-Projekt für C#enthalten.

Im Folgenden finden Sie einige der Beispiele, die in diesem Artikel enthalten sind:

Erstellen einer Formatzeichenfolge

Einfügen einer Zeichenfolge
Das Formatelement
Formatieren von Elementen mit demselben Index

Steuern der formatierten Ausgabe

Steuern der Formatierung
Steuern des Abstands
Steuern der Ausrichtung
Steuern der Anzahl ganzzahligen Ziffern
Steuern der Anzahl von Ziffern nach dem Dezimaltrennzeichen
Einschließen von literalen geschweiften Klammern in eine Ergebniszeichenfolge

Kulturabhängiges Gestalten von Formatzeichenfolgen

Kulturabhängige Formatierung

Anpassen des Formatierungsvorgangs

Ein benutzerdefinierter Formatierungsvorgang
Ein Intercept-Anbieter und ein lateinisches Zahlenformatierer

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

In diesem Abschnitt

Erste Schritte mit der String.Format-Methode
Welche Methode rufe ich auf?
Die Format-Methode in Kürze
Das Format-Element
Formatieren von Argumenten
Formatieren von Elementen mit demselben Index
Formatierung und Kultur
Benutzerdefinierte Formatierungsvorgänge
String.Format Q & A

Erste Schritte mit der String.Format-Methode

Verwenden Sie , wenn Sie den Wert eines Objekts, einer Variablen oder eines Ausdrucks in eine String.Format andere Zeichenfolge einfügen müssen. Beispielsweise können Sie den Wert eines Werts in eine Zeichenfolge einfügen, um ihn dem Benutzer als Decimal einzelne Zeichenfolge anzuzeigen:

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

Und Sie können die Formatierung dieses Werts steuern:

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

Neben der Formatierung können Sie auch die Ausrichtung und den Abstand steuern.

Einfügen einer Zeichenfolge

String.Format beginnt mit einer Formatzeichenfolge, gefolgt von einem oder mehr Objekten oder Ausdrücken, die in Zeichenfolgen konvertiert und an einer angegebenen Stelle in der Formatzeichenfolge eingefügt werden. Zum Beispiel:

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} in der Formatzeichenfolge ist ein Formatelement. 0 ist der Index des Objekts, dessen Zeichenfolgenwert an dieser Position eingefügt wird. (Indizes beginnen bei 0.) Wenn das zu einfügende Objekt keine Zeichenfolge ist, wird seine -Methode aufgerufen, um es in eine Zeichenfolge zu konvertieren, bevor es ToString in die Ergebniszeichenfolge eingefügt wird.

Hier ist ein weiteres Beispiel, in dem zwei Formatelemente und zwei Objekte in der Objektliste verwendet werden:

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 so viele Formatelemente und Objekte in der Objektliste enthalten, wie Sie möchten, solange der Index jedes Formatelements über ein entsprechendes Objekt in der Objektliste verfügt. Sie müssen sich auch keine Gedanken darüber machen, welche Überladung Sie aufrufen. Der Compiler wählt den passenden für Sie aus.

Steuerelementformatierung

Sie können dem Index in einem Formatelement mit einer Formatzeichenfolge folgen, um zu steuern, wie ein Objekt formatiert wird. Beispielsweise wendet {0:d} die Formatzeichenfolge "d" auf das erste Objekt in der Objektliste an. Hier ist ein Beispiel mit einem einzelnen Objekt und zwei Formatelementen:

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

Eine Reihe von Typen unterstützen Formatzeichenfolgen, einschließlich aller numerischen Typen (sowohl Standard- als auch benutzerdefinierte Formatzeichenfolgen), aller Datums- und Uhrzeitangaben (standard- und benutzerdefinierte Formatzeichenfolgen) und Zeitintervalle (standard- und benutzerdefinierte Formatzeichenfolgen), aller Enumerationstypen Enumerationstypen und GUIDs. Sie können ihren eigenen Typen auch Unterstützung für Formatzeichenfolgen hinzufügen.

Steuern des Abstands

Sie können die Breite der Zeichenfolge definieren, die in die Ergebniszeichenfolge eingefügt wird, indem Sie eine Syntax wie verwenden, die eine {0,12} Zeichenfolge mit 12 Zeichen eingibt. In diesem Fall wird die Zeichenfolgendarstellung des ersten Objekts rechtsbündig im 12-Zeichen-Feld ausgerichtet. (Wenn die Zeichenfolgendarstellung des ersten Objekts jedoch mehr als 12 Zeichen lang ist, wird die bevorzugte Feldbreite ignoriert, und die gesamte Zeichenfolge wird in die Ergebniszeichenfolge eingefügt.)

Im folgenden Beispiel wird ein 6-Zeichen-Feld definiert, das die Zeichenfolge "Year" und einige Jahreszeichenfolgen sowie ein 15-Zeichen-Feld enthält, das die Zeichenfolge "Population" und einige Populationsdaten enthält. Beachten Sie, dass die Zeichen im Feld rechtsbündig ausgerichtet sind.

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

     Console.WriteLine(sb);

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

Steuerungsausrichtung

Standardmäßig werden Zeichenfolgen innerhalb ihres Felds rechtsbündig ausgerichtet, wenn Sie eine Feldbreite angeben. Um Zeichenfolgen in einem Feld linksbündig auszurichten, wird der Feldbreite ein negatives Vorzeichen vorgefertigt, z. B. , um ein {0,-12} 12-Zeichen-Feld mit linksbündiger Ausrichtung zu definieren.

Das folgende Beispiel ähnelt dem vorherigen Beispiel, mit der Ausnahme, dass sowohl Bezeichnungen als auch Daten linksbiert ausgerichtet werden.

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 nutzt das Feature für die zusammengesetzte Formatierung. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung.

Welche Methode rufe ich auf?

Beschreibung Aufruf
Formatieren Sie ein oder mehrere -Objekte mithilfe der Konventionen der aktuellen Kultur. Mit Ausnahme der Überladungen, die einen -Parameter enthalten, enthalten die verbleibenden Überladungen einen Parameter gefolgt von provider Format einem oder mehr String Objektparametern. Aus diesem Grund müssen Sie nicht bestimmen, welche Format Überladung Sie aufrufen möchten. Ihr Sprachcompiler wählt die entsprechende Überladung aus den Überladungen aus, die keinen Parameter haben, basierend provider auf Ihrer Argumentliste. Wenn Ihre Argumentliste beispielsweise über fünf Argumente verfügt, ruft der Compiler die -Methode Format(String, Object[]) auf.
Formatieren Sie ein oder mehrere Objekte mithilfe der Konventionen einer bestimmten Kultur. Auf Format jede Überladung, die mit einem provider Parameter beginnt, folgen ein Parameter und mindestens String ein Objektparameter. Aus diesem Grund müssen Sie nicht bestimmen, welche bestimmte Format Überladung Sie aufrufen möchten. Ihr Sprachcompiler wählt die entsprechende Überladung aus den Überladungen aus, die über einen provider -Parameter verfügen, basierend auf Ihrer Argumentliste. Wenn Ihre Argumentliste beispielsweise über fünf Argumente verfügt, ruft der Compiler die -Methode Format(IFormatProvider, String, Object[]) auf.
Führen Sie einen benutzerdefinierten Formatierungsvorgang entweder mit einer ICustomFormatter -Implementierung oder einer -Implementierung IFormattable aus. Jede der vier Überladungen mit einem provider -Parameter. Der Compiler wählt die entsprechende Überladung aus den Überladungen aus, die über einen provider -Parameter verfügen, basierend auf Ihrer Argumentliste.

Die Format-Methode in Kürze

Jede Überladung der -Methode verwendet das Feature für die kombinierte Formatierung, um nullbasierte indizierte Platzhalter, die als Formatelemente bezeichnet werden, in eine zusammengesetzte Format Formatzeichenfolge ein include. Zur Laufzeit wird jedes Formatelement durch die Zeichenfolgendarstellung des entsprechenden Arguments in einer Parameterliste ersetzt. Wenn der Wert des Arguments null ist, wird das Formatelement durch String.Empty ersetzt. Der folgende Aufruf der -Methode enthält beispielsweise eine Formatzeichenfolge mit drei Formatelementen, , und und eine Argumentliste Format(String, Object, Object, Object) {0} mit drei {1} {2} Elementen.

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 Formatelement

Ein Formatelement hat die folgende Syntax:

{index[,alignment][:formatString]}

Klammern geben optionale Elemente an. Die öffnenden und schließenden geschweiften Klammern sind erforderlich. (Informationen zum Einschluss einer literalen öffnenden oder schließenden geschweiften Klammer in die Formatzeichenfolge finden Sie im Abschnitt Geschweifte Klammern mit Vorzeichen im Artikel Zusammengesetzte Formatierung.)

Beispielsweise kann ein Formatelement zum Formatieren eines Währungswerts wie das folgende aussehen:

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

Ein Formatelement verfügt über die folgenden Elemente:

index
Der nullbasierte Index des Arguments, dessen Zeichenfolgendarstellung an dieser Position in die Zeichenfolge eingeschlossen werden soll. Wenn dieses Argument null ist, wird eine leere Zeichenfolge an dieser Position in die Zeichenfolge eingeschlossen.

Ausrichtung
Optional. Eine ganze Zahl mit Vorzeichen, die die Gesamtlänge des Felds angibt, in das das Argument eingefügt wird, und ob es rechtsbündig (eine positive ganze Zahl) oder linksbündig (eine negative ganze Zahl) ausgerichtet ist. Wenn Sie die Ausrichtung weglassen, wird die Zeichenfolgendarstellung des entsprechenden Arguments in ein Feld ohne führende oder nachstellende Leerzeichen eingefügt.

Wenn der Wert der Ausrichtung kleiner als die Länge des einfügenden Arguments ist, wird die Ausrichtung ignoriert, und die Länge der Zeichenfolgendarstellung des Arguments wird als Feldbreite verwendet.

Formatstring
Optional. Eine Zeichenfolge, die das Format der Ergebniszeichenfolge des entsprechenden Arguments angibt. Wenn Sie formatString weglassen, wird die parameterlose Methode des entsprechenden Arguments aufgerufen, ToString um die Zeichenfolgendarstellung zu erzeugen. Wenn Sie formatString angeben, muss das Argument, auf das das Formatelement verweist, die -Schnittstelle IFormattable implementieren. Folgende Typen unterstützen Formatzeichenfolgen:

Beachten Sie jedoch, dass jeder benutzerdefinierte Typ die Implementierung eines vorhandenen Typs implementieren IFormattable oder erweitern IFormattable kann.

Im folgenden Beispiel werden die Argumente alignment und formatString verwendet, um eine formatierte Ausgabe zu erzeugen.

using namespace System;

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

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

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

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

Formatieren von Argumenten

Formatelemente werden sequenziell ab dem Anfang der Zeichenfolge verarbeitet. Jedes Formatelement verfügt über einen Index, der einem Objekt in der Argumentliste der Methode entspricht. Die Format -Methode ruft das Argument ab und leitet seine Zeichenfolgendarstellung wie folgt ab:

  • Wenn das Argument null ist, fügt die Methode in String.Empty die Ergebniszeichenfolge ein. Sie müssen sich nicht um die Behandlung von für NullReferenceException NULL-Argumente sorgen.

  • Wenn Sie die Überladung aufrufen und die Implementierung des Objekts eine Implementierung zurückgibt, die nicht NULL ist, wird das Argument Format(IFormatProvider, String, Object[]) provider an die IFormatProvider.GetFormat ICustomFormatter -Methode ICustomFormatter.Format(String, Object, IFormatProvider) übergeben. Wenn das Formatelement ein formatString-Argument enthält, wird es als erstes Argument an die Methode übergeben. Wenn die Implementierung verfügbar ist und eine Zeichenfolge erzeugt, die nicht NULL ist, wird diese Zeichenfolge als Zeichenfolgendarstellung des Arguments zurückgegeben. Andernfalls wird der ICustomFormatter nächste Schritt ausgeführt.

  • Wenn das Argument die -Schnittstelle IFormattable implementiert, wird IFormattable.ToString dessen Implementierung aufgerufen.

  • Die parameterlose Methode des Arguments, die entweder überschreibt oder von einer Basisklassenimplementierung ToString erbt, wird aufgerufen.

Ein Beispiel, das Aufrufe der -Methode abfing und Ihnen ermöglicht, zu sehen, welche Informationen die -Methode an eine Formatierungsmethode für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge übergibt, finden Sie unter Beispiel: Ein Intercept-Anbieter und der Formatierungsformatierung für die romanische ICustomFormatter.Format Format Zahl.

Weitere Informationen finden Sie im Abschnitt Verarbeitungs reihenfolge des Artikels Zusammengesetzte Formatierung.

Formatieren von Elementen mit demselben Index

Die -Methode löst eine Ausnahme aus, wenn der Index eines Indexelements größer oder gleich der Anzahl von Argumenten Format FormatException in der Argumentliste ist. kann jedoch mehr Formatelemente als Argumente enthalten, solange format mehrere Formatelemente denselben Index haben. Im Aufruf der -Methode im folgenden Beispiel verfügt die Argumentliste über ein einzelnes Argument, aber die Formatzeichenfolge enthält zwei Formatelemente: eins zeigt den Dezimalwert einer Zahl an, und das andere zeigt seinen Format(String, Object) Hexadezimalwert an.

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

Format und Kultur

Im Allgemeinen werden Objekte in der Argumentliste mithilfe der Konventionen der aktuellen Kultur, die von der -Eigenschaft zurückgegeben wird, in ihre Zeichenfolgendarstellungen CultureInfo.CurrentCulture konvertiert. Sie können dieses Verhalten steuern, indem Sie eine der Überladungen von Format aufrufen, die einen -Parameter provider enthält. Der -Parameter ist eine Implementierung, die benutzerdefinierte und kulturspezifische Formatierungsinformationen zur Moderation provider IFormatProvider des Formatierungsprozesses angibt.

Die -Schnittstelle verfügt über einen einzelnen Member, , der für die Rückgabe des Objekts verantwortlich IFormatProvider GetFormat ist, das Formatierungsinformationen enthält. .NET verfügt über drei IFormatProvider Implementierungen, die kulturspezifische Formatierung bereitstellen:

  • CultureInfo. Die -Methode gibt ein kulturspezifisches Objekt zum Formatieren numerischer Werte und ein kulturspezifisches Objekt zum Formatieren von GetFormat NumberFormatInfo Datums- und DateTimeFormatInfo Uhrzeitwerten zurück.

  • DateTimeFormatInfo, das für die kulturspezifische Formatierung von Datums- und Uhrzeitwerten verwendet wird. Die GetFormat -Methode gibt sich selbst zurück.

  • NumberFormatInfo, das für die kulturspezifische Formatierung numerischer Werte verwendet wird. Die GetFormat -Eigenschaft gibt sich selbst zurück.

Benutzerdefinierte Formatierungsvorgänge

Sie können auch alle Überladungen der -Methode aufrufen, die über einen Parameter vom Typ verfügen, um Format provider IFormatProvider benutzerdefinierte Formatierungsvorgänge durchzuführen. Beispielsweise können Sie eine ganze Zahl als ID oder Telefonnummer formatieren. Um benutzerdefinierte Formatierungen durchzuführen, muss provider Ihr Argument sowohl die -Schnittstelle als auch die IFormatProvider -Schnittstelle ICustomFormatter implementieren. Wenn der Methode eine Implementierung als Argument übergeben wird, ruft die Methode ihre Implementierung auf und fordert Format ein Objekt vom Typ ICustomFormatter provider Format IFormatProvider.GetFormat ICustomFormatter an. Anschließend ruft er die -Methode des ICustomFormatter zurückgegebenen Objekts auf, um jedes Formatelement in der zusammengesetzten Format Zeichenfolge zu formatieren, die ihm übergeben wird.

Weitere Informationen zum Bereitstellen benutzerdefinierter Formatierungslösungen finden Sie unter How to: Define and Use Custom Numeric Format Providers and ICustomFormatter . Ein Beispiel, in dem ganze Zahlen in formatierte benutzerdefinierte Zahlen konvertiert werden, finden Sie unter Beispiel: Ein benutzerdefinierter Formatierungsvorgang. Ein Beispiel, in dem nicht signierte Bytes in romanische Zahlen konvertiert werden, finden Sie unter Beispiel: Ein Schnittabfanganbieter und das Formatierungsformatieren für die romanische Zahl.

Beispiel: Ein benutzerdefinierter Formatierungsvorgang

In diesem Beispiel wird ein Formatanbieter definiert, der einen ganzzahligen Wert als Kundenkontonummer im Format x-xxxxx-xx formatiert.

using namespace System;

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

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

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

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

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

Beispiel: Ein Intercept provider and Roman numeral formatter

In diesem Beispiel wird ein benutzerdefinierter Formatanbieter definiert, der die Schnittstellen ICustomFormatter und IFormatProvider implementiert, um zwei Dinge zu tun:

  • Es zeigt die Parameter an, die an seine Implementierung übergeben ICustomFormatter.Format werden. Dadurch können wir sehen, welche Parameter die Methode an die benutzerdefinierte Formatierungsimplementierung für jedes Objekt über gibt, Format(IFormatProvider, String, Object[]) das sie zu formatieren versucht. Dies kann nützlich sein, wenn Sie Ihre Anwendung debuggen.

  • Wenn das zu formatierte Objekt ein Bytewert ohne Vorzeichen ist, der mithilfe der Standardformatzeichenfolge "R" formatiert werden soll, formatiert das benutzerdefinierte Formatierungsformat den numerischen Wert als numerische Zahl.

using namespace System;
using namespace System::Globalization;

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

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

         return returnString; 
      }   

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

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

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

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

         return returnString; 
      }   

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

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

Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
         Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

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

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

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

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

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

String.Format Q & A

Warum empfehlen Sie die Zeichenfolgeninterpolation über Aufrufe der String.Format -Methode?

Die Zeichenfolgeninterpolation ist:

  • Flexibler. Sie kann in jeder Zeichenfolge verwendet werden, ohne dass ein Aufruf einer Methode erforderlich ist, die die kombinierte Formatierung unterstützt. Andernfalls müssen Sie die -Methode oder eine andere Methode aufrufen, die die kombinierte Formatierung unterstützt, z. Format B. Console.WriteLine oder StringBuilder.AppendFormat .

  • Besser lesbar. Da der ausdruck, der in eine Zeichenfolge eingefügt werden soll, im interpolierten Ausdruck und nicht in einer Argumentliste angezeigt wird, sind interpolierte Zeichenfolgen wesentlich einfacher zu codieren und zu lesen. Aufgrund ihrer besseren Lesbarkeit können interpolierte Zeichenfolgen nicht nur Aufrufe zusammengesetzter Formatmethoden ersetzen, sondern auch in Zeichenfolgen-Verkettungsvorgängen verwendet werden, um präziseren, übersichtlicheren Code zu erzeugen.

Ein Vergleich der folgenden beiden Codebeispiele veranschaulicht die Überlegenheit interpolierter Zeichenfolgen gegenüber der Zeichenfolgenübereinkettung und aufruft zusammengesetzte Formatierungsmethoden. Die Verwendung mehrerer Zeichenfolgenverkettungsvorgänge im folgenden Beispiel erzeugt ausführlichen und schwer lesbaren Code.

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

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

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

Im Gegensatz dazu erzeugt die Verwendung interpolierter Zeichenfolgen im folgenden Beispiel deutlich klareren, präziseren Code als die Zeichenfolgen-Verkettungsanweisung und den Aufruf der -Methode im vorherigen Format Beispiel.

  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 Formatelementen verwendet werden können?

Gewusst wie die Ausrichtung der Ergebniszeichenfolgen steuern, die Formatelemente ersetzen?

Die allgemeine Syntax eines Formatelements ist:

{index[,alignment][: formatString]}

Wobei ausrichtung eine ganze Zahl mit Vorzeichen ist, die die Feldbreite definiert. Wenn dieser Wert negativ ist, wird der Text im Feld linksbündig ausgerichtet. Wenn der Text positiv ist, wird er rechtsbündig ausgerichtet.

Gewusst wie die Anzahl der Ziffern nach dem Dezimaltrennzeichen steuern?

Alle standardmäßigen numerischen Formatzeichenfolgen außer "D" (wird nur bei ganzen Zahlen verwendet), "G", "R" und "X" ermöglichen einen Genauigkeitsspezifizierer, der die Anzahl der Dezimalstellen in der Ergebniszeichenfolge definiert. Im folgenden Beispiel werden standardmäßige numerische Formatzeichenfolgen verwendet, um die Anzahl der Dezimalstellen in der Ergebniszeichenfolge zu steuern.

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

Wenn Sie eine benutzerdefinierte numerische Formatzeichenfolge verwenden,verwenden Sie den Formatbezeichner "0", um die Anzahl der Dezimalstellen in der Ergebniszeichenfolge zu steuern, wie im folgenden Beispiel gezeigt.

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

Gewusst wie die Anzahl ganzzahliger Ziffern steuern?

Standardmäßig zeigen Formatierungsvorgänge nur ganzzahlige Ziffern ohne Null an. Wenn Sie ganze Zahlen formatieren, können Sie einen Genauigkeitsspezifizierer mit den Standardformatzeichenfolgen "D" und "X" verwenden, um die Anzahl von Ziffern zu steuern.

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

Sie können eine ganze Zahl oder Gleitkommazahl mit führenden Nullen aufpaddieren, um eine Ergebniszeichenfolge mit einer angegebenen Anzahl von ganzzahligen Ziffern zu erzeugen, indem Sie den benutzerdefinierten numerischen Formatbezeichner "0" verwenden, wie im folgenden Beispiel gezeigt.

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

Wie viele Elemente kann ich in die Formatliste aufgenommen werden?

Es gibt keinen praktischen Grenzwert. Der zweite Parameter der Methode wird mit dem -Attribut markiert, mit dem Sie entweder eine durch Trennzeichen getrennte Liste oder ein Objektarray Format(IFormatProvider, String, Object[]) ParamArrayAttribute als Formatliste hinzufügen können.

Gewusst wie literale geschweifte Klammern ("{" und "}") in die Ergebniszeichenfolge ein?

Wie verhindern Sie beispielsweise, dass der folgende Methodenaufruf eine Ausnahme FormatException auslöst?

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. Um wörtlich interpretiert zu werden, muss es mit Escape escapen. Sie können eine geschweifte Klammer mit escapen, indem Sie eine weitere geschweifte Klammer ("{{" und "}}" anstelle von "{" und "}") hinzufügen, wie im folgenden Methodenaufruf zu sehen:

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

Selbst geschweifte Klammern werden jedoch leicht falsch interpretiert. Es wird empfohlen, dass Sie geschweifte Klammern in die Formatliste einfügen und Formatelemente verwenden, um sie in die Ergebniszeichenfolge einfügen, wie im folgenden Beispiel gezeigt.

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

Warum löst mein Aufruf der String.Format-Methode eine FormatException aus?

Die häufigste Ursache der Ausnahme ist, dass der Index eines Formatelements keinem Objekt in der Formatliste entspricht. In der Regel deutet dies darauf hin, dass Sie die Indizes von Formatelementen falsch nummeriert haben oder vergessen haben, ein Objekt in die Formatliste aufzunehmen. Der Versuch, ein linkes oder rechtes geschweifte Klammerzeichen ohne Klammer einzuschließen, löst ebenfalls eine FormatException aus. Gelegentlich ist die Ausnahme das Ergebnis eines Tippfehlers. Ein typischer Fehler besteht beispielsweise darin, "[" (die linke Klammer) anstelle von "{" (linke geschweifte Klammer) falsch einzutipgen.

Warum löst mein Code bei Verwendung eines Arrays eine Ausnahme aus, wenn die Format(System.IFormatProvider,System.String,System.Object[])-Methode Parameterarrays unterstützt?

Der folgende Code löst beispielsweise eine FormatException Ausnahme aus:

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

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

Dies ist ein Problem bei der Auflösung von Compilerüberladungen. Da der Compiler ein Array von ganzen Zahlen nicht in ein Objektarray konvertieren kann, behandelt er das Ganzzahlarray als einzelnes Argument und ruft daher die Format(String, Object) -Methode auf. Die Ausnahme wird ausgelöst, da es vier Formatelemente gibt, aber nur ein einzelnes Element in der Formatliste.

Da weder Visual Basic noch C# ein Ganzzahlarray in ein Objektarray konvertieren können, müssen Sie die Konvertierung selbst ausführen, bevor Sie die Format(String, Object[]) -Methode aufrufen. Der folgende Code zeigt ein Implementierungsbeispiel.

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

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

Format(String, Object)

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.

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

Parameter

arg0
Object

Das zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der alle Formatelemente durch die Zeichenfolgendarstellung von arg0 ersetzt wurden.

Ausnahmen

format ist null.

Das Formatelement in format ist ungültig.

- oder -

Der Index eines Formatelements ist nicht 0 (null).

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um den Wert eines Ausdrucks in seine Zeichenfolgendarstellung zu konvertieren und diese Darstellung in eine Zeichenfolge einzubetten.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Beispiel: Formatieren eines einzelnen Arguments

Im folgenden Beispiel wird die Format(String, Object) -Methode verwendet, um das Alter einer Person in der Mitte einer Zeichenfolge einzubetten.

using namespace System;

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

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

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

Siehe auch

Gilt für

Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params 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.

Gibt zurück

String

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Objekte in args ersetzt wurden.

Ausnahmen

format oder args ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des args-Arrays.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um den Wert von vier oder mehr Ausdrücken in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Da der args Parameter mit dem -Attribut markiert System.ParamArrayAttribute ist, können Sie die Objekte als einzelne Argumente oder als Array an die Methode Object übergeben.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Beispiel: Formatieren von mehr als drei Argumenten

In diesem Beispiel wird eine Zeichenfolge erstellt, die Daten zu hoher und niedriger Temperatur an einem bestimmten Datum enthält. Die zusammengesetzte Formatzeichenfolge enthält fünf Formatelemente im C#-Beispiel und sechs im Visual Basic Beispiel. Zwei der Formatelemente definieren die Breite der Zeichenfolgendarstellung des entsprechenden Werts, und das erste Formatelement enthält auch eine Standardformatzeichenfolge für Datum und Uhrzeit.

using namespace System;

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

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

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

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

Sie können auch die Objekte übergeben, die als Array und nicht als Argumentliste formatiert werden sollen.

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

Gilt für

Format(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

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

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

arg0
Object

Das zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung von arg0 ersetzt wurden.

Ausnahmen

format ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist nicht 0 (null).

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um den Wert eines Ausdrucks in seine Zeichenfolgendarstellung zu konvertieren und diese Darstellung in eine Zeichenfolge einzubetten. Bei der Durchführung der Konvertierung verwendet die Methode kulturabhängige Formatierung oder ein benutzerdefiniertes Formatierungsformatierung. Die -Methode konvertiert arg0 in ihre Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider)-Methode oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, durch Aufrufen der ToString(String,IFormatProvider)-Methode. Wenn diese Methoden nicht vorhanden sind, ruft sie die parameterlose ToString-Methode des Objekts auf.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. 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. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Gilt für

Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

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);
public static string Format (IFormatProvider? provider, string format, params object?[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

args
Object[]

Ein Objektarray mit 0 (null) oder mehr zu formatierenden Objekten.

Gibt zurück

String

Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Objekte in args ersetzt wurden.

Ausnahmen

format oder args ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des args-Arrays.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um vier oder mehr Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Durchführung der Konvertierung verwendet die Methode kulturabhängige Formatierung oder ein benutzerdefiniertes Formatierungsformatierung. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider)-Methode oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, durch Aufrufen der ToString(String,IFormatProvider)-Methode. Wenn diese Methoden nicht vorhanden sind, ruft sie die parameterlose ToString-Methode des Objekts auf.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. 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. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Beispiel: Kulturabhängige Formatierung

In diesem Beispiel wird die Format(IFormatProvider, String, Object[]) -Methode verwendet, um die Zeichenfolgendarstellung einiger Datums- und Uhrzeitwerte und numerischer Werte unter Verwendung verschiedener Kulturen anzuzeigen.

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

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

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

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

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

Siehe auch

Gilt für

Format(String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.

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

Parameter

arg0
Object

Das erste zu formatierende Objekt.

arg1
Object

Das zweite zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0 und arg1 ersetzt wurden.

Ausnahmen

format ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist nicht 0 (null) oder 1.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um den Wert von zwei Ausdrücken in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Beispiel: Formatieren von zwei Argumenten

In diesem Beispiel wird die Format(String, Object, Object) -Methode verwendet, um Zeit- und Temperaturdaten anzuzeigen, die in einem generischen -Objekt gespeichert Dictionary<TKey,TValue> sind. Beachten Sie, dass die Formatzeichenfolge drei Formatelemente enthält, obwohl es nur zwei zu formatierende Objekte gibt. Dies liegt daran, dass das erste Objekt in der Liste (ein Datums- und Uhrzeitwert) von zwei Formatelementen verwendet wird: Das erste Formatelement zeigt die Uhrzeit und das zweite das Datum an.

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

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

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

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

Siehe auch

Gilt für

Format(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

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);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

arg0
Object

Das erste zu formatierende Objekt.

arg1
Object

Das zweite zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0 und arg1 ersetzt wurden.

Ausnahmen

format ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist nicht 0 (null) oder 1.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um zwei Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Durchführung der Konvertierung verwendet die Methode kulturabhängige Formatierung oder ein benutzerdefiniertes Formatierungsformatierung. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider)-Methode oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, durch Aufrufen der ToString(String,IFormatProvider)-Methode. Wenn diese Methoden nicht vorhanden sind, ruft sie die parameterlose ToString-Methode des Objekts auf.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. 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. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Gilt für

Format(String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.

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);
public static string Format (string format, object? arg0, object? arg1, object? arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parameter

arg0
Object

Das erste zu formatierende Objekt.

arg1
Object

Das zweite zu formatierende Objekt.

arg2
Object

Das dritte zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0, arg1 und arg2 ersetzt wurden.

Ausnahmen

format ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als 0 (null) oder größer als 2.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um den Wert von drei Ausdrücken in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. Stattdessen können Sie die Methode mit einer kombinierten Formatzeichenfolge aufrufen, die mindestens ein Formatelement enthält. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Beispiel: Formatieren von drei Argumenten

In diesem Beispiel wird die Format(String, Object, Object, Object) -Methode verwendet, um eine Zeichenfolge zu erstellen, die das Ergebnis eines booleschen And Vorgangs mit zwei ganzzahligen Werten veranschaulicht. Beachten Sie, dass die Formatzeichenfolge sechs Formatelemente enthält, die -Methode jedoch nur drei Elemente in ihrer Parameterliste enthält, da jedes Element auf zwei verschiedene Arten formatiert ist.

using namespace System;

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

Siehe auch

Gilt für

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

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);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parameter

provider
IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.

arg0
Object

Das erste zu formatierende Objekt.

arg1
Object

Das zweite zu formatierende Objekt.

arg2
Object

Das dritte zu formatierende Objekt.

Gibt zurück

String

Eine Kopie von format, in der Formatelemente durch die Zeichenfolgendarstellung von arg0, arg1 und arg2 ersetzt wurden.

Ausnahmen

format ist null.

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als 0 (null) oder größer als 2.

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. Eine interpolierte Zeichenfolge ist eine Zeichenfolge, die interpolierte Ausdrücke enthält. Jeder interpolierte Ausdruck wird mit dem Wert des Ausdrucks aufgelöst und in die Ergebniszeichenfolge aufgenommen, wenn die Zeichenfolge zugewiesen wird. Weitere Informationen finden Sie unter Zeichenfolgeninterpolation (C#-Referenz) und Interpolierte Zeichenfolgen (Visual Basic-Referenz).

Diese Methode verwendet die Funktion für die zusammengesetzte Formatierung, um drei Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Durchführung der Konvertierung verwendet die Methode kulturabhängige Formatierung oder ein benutzerdefiniertes Formatierungsformatierung. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung durch Aufrufen der ToString(IFormatProvider)-Methode oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, durch Aufrufen der ToString(String,IFormatProvider)-Methode. Wenn diese Methoden nicht vorhanden sind, ruft sie die parameterlose ToString-Methode des Objekts auf.

Wenn jedoch die String.Format-Methode aufgerufen wird, müssen Sie sich nicht auf die genaue Überladung konzentrieren, die Sie aufrufen möchten. 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. Weisen Sie jedem Formatelement einen numerischen Index zu. Der erste Index startet bei 0 (null). Neben dem ersten Zeichenfolgenwert sollte Ihr Methodenaufruf über gleich viele zusätzliche Argumente und Indexwerte verfügen. 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. Ihr Sprachcompiler ruft dann einen Methodenaufruf einer bestimmten Überladung der String.Format-Methode auf.

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?).

Gilt für