String.Format Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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(IFormatProvider, String, Object, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei 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) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen. |
| Format(String, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. |
| Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>) |
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| 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[]) |
Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array. |
| Format(String, Object) |
Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts. |
| Format(IFormatProvider, CompositeFormat, Object[]) |
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2) |
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1) |
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format<TArg0>(IFormatProvider, CompositeFormat, TArg0) |
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
Beispiele
Zahlreiche Beispiele, die die Format -Methode aufrufen, werden im Abschnitt Hinweise dieses Artikels durchsetzt.
Sie können auch eine vollständige Reihe von Beispielen String.Format herunterladen, die ein .NET Core-Projekt für C# enthalten.
Im Folgenden sind einige der Beispiele aufgeführt, die im Artikel enthalten sind:
Erstellen einer Formatzeichenfolge
Einfügen einer Zeichenfolge
Das Formatelement
Formatieren von Elementen mit demselben Index
Steuerelement formatierte Ausgabe
Steuern der Formatierung
Steuern des Abstands
Steuern der Ausrichtung
Steuern der Anzahl von integralen Ziffern
Steuern der Anzahl von Ziffern nach dem Dezimaltrennzeichen
Einschließen von Literalklammern in eine Ergebniszeichenfolge
Kultursensitive Formatzeichenfolgen
Anpassen des Formatierungsvorgangs
Ein benutzerdefinierter Formatierungsvorgang
Ein Abfanganbieter und ein römischer 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
Element Format
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 String.Format , wenn Sie den Wert eines Objekts, einer Variablen oder eines Ausdrucks in eine andere Zeichenfolge einfügen müssen. Beispielsweise können Sie den Wert eines Decimal Werts in eine Zeichenfolge einfügen, um ihn dem Benutzer als 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.
let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%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.
let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%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 mehreren Objekten oder Ausdrücken, die in Zeichenfolgen konvertiert und an einer angegebenen Stelle in die 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.'
let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%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 einzufügende Objekt keine Zeichenfolge ist, wird seine ToString Methode aufgerufen, um es in ein Objekt zu konvertieren, bevor es in die Ergebniszeichenfolge eingefügt wird.
Hier sehen Sie ein weiteres Beispiel, das zwei Formatelemente und zwei Objekte in der Objektliste verwendet:
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.'
String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%s"
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Sie können beliebig viele Formatelemente und beliebig viele Objekte in der Objektliste enthalten, solange der Index jedes Formatelements ein übereinstimmende Objekt in der Objektliste enthält. Sie müssen sich auch keine Gedanken darüber machen, welche Überlastung Sie anrufen. der Compiler wählt die für Sie geeignete aus.
Steuerelementformatierung
Sie können dem Index in einem Formatelement mit einer Formatzeichenfolge folgen, um zu steuern, wie ein Objekt formatiert wird. Wendet beispielsweise {0:d} die Formatzeichenfolge "d" auf das erste Objekt in der Objektliste an. Hier sehen Sie 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'
String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%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ützt Formatzeichenfolgen, einschließlich aller numerischen Typen (sowohl Standard - als auch benutzerdefinierte Formatzeichenfolgen), alle Datums- und Uhrzeitdaten (sowohl Standard - als auch benutzerdefinierte Formatzeichenfolgen) und Zeitintervalle (sowohl Standard - als auch benutzerdefinierte Formatzeichenfolgen), alle Enumerationstypen enumerationstypen und GUIDs. Sie können auch Unterstützung für Formatzeichenfolgen zu Ihren eigenen Typen hinzufügen.
Kontrollabstand
Sie können die Breite der Zeichenfolge definieren, die in die Ergebniszeichenfolge eingefügt wird, indem Sie Syntax wie {0,12}verwenden, die eine 12-stellige Zeichenfolge einfügt. In diesem Fall ist die Zeichenfolgendarstellung des ersten Objekts im 12-Zeichen-Feld rechtsbündig. (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-stelliges Feld definiert, das die Zeichenfolge "Year" und einige Jahreszeichenfolgen enthält, sowie ein 15-stelliges Feld, das die Zeichenfolge "Population" und einige Auffüllungsdaten enthält. Beachten Sie, dass die Zeichen im Feld rechtsbündig 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
open System
open System.Text
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore
printfn $"{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 sind Zeichenfolgen in ihrem Feld rechtsbündig, wenn Sie eine Feldbreite angeben. Um Zeichenfolgen in einem Feld linksbündig auszurichten, stellen Sie der Feldbreite ein negatives Vorzeichen voran, z {0,-12} . B. zum Definieren eines 12-stelligen linksbündigen Felds.
Das folgende Beispiel ähnelt dem vorherigen, mit dem Unterschied, dass es sowohl Bezeichnungen als auch Daten linksbündig ausgerichtet.
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
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\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 die zusammengesetzte Formatierungsfunktion. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung.
Welche Methode rufe ich auf?
| Beschreibung | Aufruf |
|---|---|
| Formatieren Sie mindestens ein Objekt mithilfe der Konventionen der aktuellen Kultur. | Mit Ausnahme der Überladungen, die einen provider Parameter enthalten, enthalten die verbleibenden Format Überladungen einen String Parameter gefolgt von einem oder mehreren Objektparametern. Aus diesem Fall müssen Sie nicht ermitteln, welche Format Überladung Sie aufrufen möchten. Ihr Sprachcompiler wählt basierend auf Ihrer Argumentliste die entsprechende Überladung aus den Überladungen provider ohne Parameter aus. Wenn Ihre Argumentliste beispielsweise fünf Argumente enthält, ruft der Compiler die -Methode auf Format(String, Object[]) . |
| Formatieren Sie ein oder mehrere Objekte mithilfe der Konventionen einer bestimmten Kultur. | Jeder Format Überladung, die mit einem provider Parameter beginnt, folgen ein String Parameter und mindestens ein Objektparameter. Aus diesem Fall müssen Sie nicht ermitteln, 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 fünf Argumente enthält, ruft der Compiler die -Methode auf Format(IFormatProvider, String, Object[]) . |
| Führen Sie einen benutzerdefinierten Formatierungsvorgang mit einer ICustomFormatter Implementierung oder einer Implementierung aus IFormattable . | Eine 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 Format -Methode verwendet die zusammengesetzte Formatierungsfunktion , um nullbasierte indizierte Platzhalter, die als Formatelemente bezeichnet werden, in einer zusammengesetzten Formatzeichenfolge einzuschließen. Zur Laufzeit wird jedes Formatelement durch die Zeichenfolgendarstellung des entsprechenden Arguments in einer Parameterliste ersetzt. Wenn der Wert des Arguments ist null, wird das Formatelement durch String.Emptyersetzt. Der folgende Aufruf der Format(String, Object, Object, Object) -Methode enthält beispielsweise eine Formatzeichenfolge mit drei Formatelementen, {0}, {1}und , und {2}eine Argumentliste mit drei 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.
open System
let dat = DateTime(2012, 1, 17, 9, 30, 0)
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// 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 weist die folgende Syntax auf:
{index[,alignment][:formatString]}
Klammern bezeichnen optionale Elemente. Die öffnenden und schließenden Klammern sind erforderlich. (Informationen zum Einschließen einer öffnenden oder schließenden Literalklammer in die Formatzeichenfolge finden Sie im Abschnitt Escaping Braces im Artikel Zusammengesetzte Formatierung .)
Ein Formatelement zum Formatieren eines Währungswerts kann beispielsweise wie folgt aussehen:
String::Format("{0,-10:C}", (Decimal) 126347.89);
var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);
open System
String.Format("{0,-10:C}", 126347.89m)
|> printfn "%s"
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 lautet null, wird eine leere Zeichenfolge an dieser Position in der Zeichenfolge eingeschlossen.
Ausrichtung
Optional. Eine ganzzahlige 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 (negative ganze Zahl) ist. Wenn Sie die Ausrichtung weglassen, wird die Zeichenfolgendarstellung des entsprechenden Arguments in ein Feld ohne führende oder nachfolgende Leerzeichen eingefügt.
Wenn der Wert der Ausrichtung kleiner als die Länge des einzufü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 ToString Methode des entsprechenden Arguments aufgerufen, um die Zeichenfolgendarstellung zu erzeugen. Wenn Sie formatString angeben, muss das Argument, auf das vom Formatelement verwiesen wird, die IFormattable Schnittstelle implementieren. Zu den Typen, die Formatzeichenfolgen unterstützen, gehören:
Alle Integral- und Gleitkommatypen. (Siehe Numerische Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.)
DateTime und DateTimeOffset. (Siehe Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen.)
Alle Enumerationstypen. (Siehe Enumerationsformatzeichenfolgen.)
TimeSpan-Werte sind. (Siehe Standard-TimeSpan-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen.)
GUIDs. (Siehe die Guid.ToString(String) -Methode.)
Beachten Sie jedoch, dass jeder benutzerdefinierte Typ die Implementierung eines vorhandenen Typs IFormattable implementieren IFormattable oder erweitern kann.
Im folgenden Beispiel werden die alignment Argumente 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 %
// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities =
[ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
"New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
"Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
"Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]
// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"
for name, year1, pop1, year2, pop2 in cities do
String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
name, year1, pop1, year2, pop2,
double (pop2 - pop1) / double pop1)
|> printfn "%s"
// 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 vom 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 lautet, fügt
nulldie -Methode in die Ergebniszeichenfolge ein String.Empty . Sie müssen sich nicht um die Behandlung von argumenten NullReferenceException für null kümmern.Wenn Sie die Format(IFormatProvider, String, Object[]) Überladung aufrufen und die
providerImplementierung des IFormatProvider.GetFormat Objekts eine Implementierung ungleich NULL ICustomFormatter zurückgibt, wird das Argument an die - ICustomFormatter.Format(String, Object, IFormatProvider) Methode übergeben. Wenn das Formatelement ein formatString-Argument enthält, wird es als erstes Argument an die -Methode übergeben. Wenn die ICustomFormatter Implementierung verfügbar ist und eine Zeichenfolge ungleich NULL erzeugt, wird diese Zeichenfolge als Zeichenfolgendarstellung des Arguments zurückgegeben. Andernfalls wird der nächste Schritt ausgeführt.Wenn das Argument die IFormattable Schnittstelle implementiert, wird deren IFormattable.ToString Implementierung aufgerufen.
Die parameterlose
ToStringMethode des Arguments, die entweder überschreibt oder von einer Basisklassenimplementierung erbt, wird aufgerufen.
Ein Beispiel, das Aufrufe der ICustomFormatter.Format -Methode abfängt und ihnen ermöglicht, zu sehen, welche Informationen die Format Methode an eine Formatierungsmethode für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge übergibt, finden Sie unter Beispiel: Ein Abfanganbieter und ein römischer Zahlenformatierer.
Weitere Informationen finden Sie im Abschnitt Verarbeitungsreihenfolge im Artikel Zusammengesetzte Formatierung .
Formatieren von Elementen mit demselben Index
Die Format -Methode löst eine Ausnahme aus FormatException , wenn der Index eines Indexelements größer oder gleich der Anzahl von Argumenten in der Argumentliste ist. Kann jedoch mehr Formatelemente enthalten, format als Argumente vorhanden sind, solange mehrere Formatelemente denselben Index aufweisen. Beim Aufruf der Format(String, Object) -Methode im folgenden Beispiel enthält die Argumentliste ein einzelnes Argument, aber die Formatzeichenfolge enthält zwei Formatelemente: Eines zeigt den Dezimalwert einer Zahl an, und das andere zeigt den hexadezimalen Wert 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
open System
let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s %10s\n" "Decimal" "Hex"
for value in values do
String.Format("{0,10:G}: {0,10:X}", value)
|> printfn "%s"
// 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 in ihre Zeichenfolgendarstellungen konvertiert, die von der CultureInfo.CurrentCulture -Eigenschaft zurückgegeben wird. Sie können dieses Verhalten steuern, indem Sie eine der Überladungen von Format aufrufen, die einen provider Parameter enthält. Der provider Parameter ist eine IFormatProvider Implementierung, die benutzerdefinierte und kulturspezifische Formatierungsinformationen bereitstellt, die zum Moderieren des Formatierungsprozesses verwendet werden.
Die IFormatProvider Schnittstelle verfügt über ein einzelnes Element, GetFormatdas für die Rückgabe des Objekts verantwortlich ist, das Formatierungsinformationen bereitstellt. .NET verfügt über drei IFormatProvider Implementierungen, die kulturspezifische Formatierungen bieten:
CultureInfo. Ihre GetFormat Methode gibt ein kulturspezifisches NumberFormatInfo Objekt zum Formatieren numerischer Werte und ein kulturspezifisches DateTimeFormatInfo Objekt zum Formatieren von Datums- und Uhrzeitwerten zurück.
DateTimeFormatInfo, die 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. Seine GetFormat Eigenschaft gibt sich selbst zurück.
Benutzerdefinierte Formatierungsvorgänge
Sie können auch die Überladungen der -Methode aufrufen, die Format über einen provider Parameter vom Typ IFormatProvider verfügen, um benutzerdefinierte Formatierungsvorgänge auszuführen. Sie könnten beispielsweise eine ganze Zahl als Identifikationsnummer oder als Telefonnummer formatieren. Zum Ausführen einer benutzerdefinierten Formatierung muss Ihr provider Argument sowohl die IFormatProvider Schnittstellen als ICustomFormatter auch implementieren. Wenn die Format -Methode eine ICustomFormatter Implementierung als provider Argument übergeben wird, ruft die Methode ihre FormatIFormatProvider.GetFormat Implementierung auf und fordert ein Objekt vom Typ an ICustomFormatter. Anschließend wird die Methode des zurückgegebenen ICustomFormatter Objekts Format aufgerufen, um jedes Formatelement in der an ihn übergebenen zusammengesetzten Zeichenfolge zu formatieren.
Weitere Informationen zum Bereitstellen benutzerdefinierter Formatierungslösungen finden Sie unter Gewusst wie: Definieren und Verwenden von benutzerdefinierten numerischen Formatanbietern und ICustomFormatter. Ein Beispiel, das ganze Zahlen in formatierte benutzerdefinierte Zahlen konvertiert, finden Sie unter Beispiel: Ein benutzerdefinierter Formatierungsvorgang. Ein Beispiel, das bytes ohne Vorzeichen in römische Zahlen konvertiert, finden Sie unter Beispiel: Ein Abfanganbieter und ein römischer Zahlenformatierer.
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.
open System
type CustomerFormatter() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member this.Format(format, arg, formatProvider: IFormatProvider) =
if this.Equals formatProvider |> not then
null
else
let format =
if String.IsNullOrEmpty format then "G"
else format.ToUpper()
let customerString =
let s = string arg
if s.Length < 8 then
s.PadLeft(8, '0')
else s
match format with
| "G" ->
customerString.Substring(0, 1) + "-" +
customerString.Substring(1, 5) + "-" +
customerString.Substring 6
| "S" ->
customerString.Substring(0, 1) + "/" +
customerString.Substring(1, 5) + "/" +
customerString.Substring 6
| "P" ->
customerString.Substring(0, 1) + "." +
customerString.Substring(1, 5) + "." +
customerString.Substring 6
| _ ->
raise (FormatException $"The '{format}' format specifier is not supported.")
let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
String.Format(CustomerFormatter(), "{0:X}", acctNumber)
|> printfn "%s"
with :? FormatException as e ->
printfn $"{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.
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 Abfanganbieter und ein römischer Zahlenformatierer
In diesem Beispiel wird ein benutzerdefinierter Formatanbieter definiert, der die ICustomFormatter Schnittstellen und IFormatProvider implementiert, um zwei Aufgaben zu erfüllen:
Es zeigt die Parameter an, die an die ICustomFormatter.Format Implementierung übergeben wurden. Dadurch können wir sehen, welche Parameter die Format(IFormatProvider, String, Object[]) Methode an die implementierung der benutzerdefinierten Formatierung für jedes Objekt übergibt, das sie formatieren möchte. Dies kann nützlich sein, wenn Sie Ihre Anwendung debuggen.
Wenn es sich bei dem zu formatierenden Objekt um einen Wert ohne Vorzeichen handelt, der mithilfe der Standardformatzeichenfolge "R" formatiert werden soll, formatiert der benutzerdefinierte Formatierer den numerischen Wert als römische 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
open System
open System.Globalization
type InterceptProvider() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member _.Format(format, obj, provider: IFormatProvider) =
// Display information about method call.
let formatString =
if format = null then "<null>" else format
printfn $"Provider: {provider.GetType().Name}, Object: %A{obj}, Format String: %s{formatString}"
if obj = null then
String.Empty
else
// If this is a byte and the "R" format string, format it with Roman numerals.
match obj with
| :? byte as value when formatString.ToUpper().Equals "R" ->
let mutable returnString = String.Empty
// Get the hundreds digit(s)
let struct (result, remainder) = Math.DivRem(value, 100uy)
if result > 0uy then
returnString <- String('C', int result)
let value = byte remainder
// Get the 50s digit
let struct (result, remainder) = Math.DivRem(value, 50uy)
if result = 1uy then
returnString <- returnString + "L"
let value = byte remainder
// Get the tens digit.
let struct (result, remainder) = Math.DivRem(value, 10uy)
if result > 0uy then
returnString <- returnString + String('X', int result)
let value = byte remainder
// Get the fives digit.
let struct (result, remainder) = Math.DivRem(value, 5uy)
if result > 0uy then
returnString <- returnString + "V"
let value = byte remainder
// Add the ones digit.
if remainder > 0uy then
returnString <- returnString + String('I', int remainder)
// Check whether we have too many X characters.
let pos = returnString.IndexOf "XXXX"
if pos >= 0 then
let xPos = returnString.IndexOf "L"
returnString <-
if xPos >= 0 && xPos = pos - 1 then
returnString.Replace("LXXXX", "XC")
else
returnString.Replace("XXXX", "XL")
// Check whether we have too many I characters
let pos = returnString.IndexOf "IIII"
if pos >= 0 then
returnString <-
if returnString.IndexOf "V" >= 0 then
returnString.Replace("VIIII", "IX")
else
returnString.Replace("IIII", "IV")
returnString
// Use default for all other formatting.
| :? IFormattable as x ->
x.ToString(format, CultureInfo.CurrentCulture)
| _ ->
string obj
let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// 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. Es kann in jeder Zeichenfolge verwendet werden, ohne dass ein Aufruf einer Methode erforderlich ist, die zusammengesetzte Formatierung unterstützt. Andernfalls müssen Sie die Format -Methode oder eine andere Methode aufrufen, die zusammengesetzte Formatierung unterstützt, z Console.WriteLine . B. 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 viel einfacher zu programmieren und zu lesen. Aufgrund ihrer besseren Lesbarkeit können interpolierte Zeichenfolgen nicht nur Aufrufe von Methoden im zusammengesetzten Format ersetzen, sondern auch in Zeichenfolgenverkettungsvorgängen verwendet werden, um präziseren, klareren Code zu erzeugen.
Ein Vergleich der folgenden beiden Codebeispiele veranschaulicht die Überlegenheit interpolierter Zeichenfolgen gegenüber Zeichenfolgenverkettung und Aufrufen zusammengesetzter Formatierungsmethoden. Die Verwendung mehrerer Verkettungsvorgänge für Zeichenfolgen im folgenden Beispiel erzeugt ausführlichen und schwer zu lesenden 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.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output =
names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6] + "\n"
let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// 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 viel klareren, präziseren Code als die Zeichenfolgenverkettungsanweisung und der Aufruf der Format -Methode im vorherigen 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.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, {names[5]}, {names[6]}"
let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s"
// 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?
Informationen zu allen integralen Typen und Gleitkommatypen finden Sie unter Numerische Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.
Datums- und Uhrzeitwerte finden Sie unter Standard-Datums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen.
Informationen zu Enumerationswerten finden Sie unter Enumerationsformatzeichenfolgen.
Werte TimeSpan finden Sie unter Standard-TimeSpan-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen.
Werte Guid finden Sie im Abschnitt Hinweise der Guid.ToString(String) Referenzseite.
Gewusst wie die Ausrichtung der Ergebniszeichenfolgen steuern, die Formatelemente ersetzen?
Die allgemeine Syntax eines Formatelements lautet:
{index[,alignment][: formatString]}
wobei die Ausrichtung eine ganzzahlige Vorzeichen ist, die die Feldbreite definiert. Wenn dieser Wert negativ ist, ist der Text im Feld linksbündig. Wenn er positiv ist, ist der Text rechtsbündig.
Gewusst wie die Anzahl der Ziffern nach dem Dezimaltrennzeichen steuern?
Alle numerischen Standardformatzeichenfolgen mit Ausnahme von "D" (die nur mit ganzzahligen Zahlen verwendet wird), "G", "R" und "X" ermöglichen einen Genauigkeitsbezeichner, 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 %
open System
let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
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.)
|> printfn "%s"
// 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
let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
Module Example
Public Sub Main()
Dim value As Decimal = 16309.5436d
Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16309.54360 16,309.54 16309.544
Gewusst wie die Anzahl der integralen Ziffern steuern?
Standardmäßig werden bei Formatierungsvorgängen nur Nicht-Null-Integralziffern angezeigt. Wenn Sie ganze Zahlen formatieren, können Sie einen Genauigkeitsbezeichner mit den Standardformatzeichenfolgen "D" und "X" verwenden, um die Anzahl der 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
open System
let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// 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 ganzzahlige Zahl oder Gleitkommazahl mit führenden Nullen versehen, um eine Ergebniszeichenfolge mit einer angegebenen Anzahl von integralen 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
open System
let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// 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 aufnehmen?
Es gibt keine praktischen Grenzen. Der zweite Parameter der Format(IFormatProvider, String, Object[]) -Methode wird mit dem ParamArrayAttribute -Attribut markiert, sodass Sie entweder eine durch Trennzeichen getrennte Liste oder ein Objektarray als Formatliste einschließen können.
Gewusst wie literale Klammern ("{" und "}") in die Ergebniszeichenfolge einschließen?
Wie verhindern Sie beispielsweise, dass der folgende Methodenaufruf eine FormatException Ausnahme auslöst?
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose);
let 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 Klammer wird immer als Anfang oder Ende eines Formatelements interpretiert. Damit sie wörtlich interpretiert werden kann, muss sie escaped werden. Sie escapen eine Klammer, indem Sie eine weitere Klammer ("{{" und "}}" anstelle von "{" und "}") hinzufügen, wie im folgenden Methodenaufruf:
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose);
Console.WriteLine(result);
let 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)
Selbst escapede Klammern werden jedoch leicht fehlinterpretiert. Es wird empfohlen, Klammern in die Formatliste aufzunehmen und sie mithilfe von Formatelementen in die Ergebniszeichenfolge einzufügen, wie das folgende Beispiel zeigt.
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);
let result =
String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.", nOpen, "{", nClose, "}")
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 für die Ausnahme ist, dass der Index eines Formatelements nicht einem Objekt in der Formatliste entspricht. In der Regel bedeutet dies, dass Sie die Indizes von Formatelementen falsch nummeriert haben oder vergessen haben, ein Objekt in die Formatliste aufzunehmen. Wenn Sie versuchen, ein unescaped linkes oder rechtes Klammerzeichen einzuschließen, wird auch ein FormatExceptionausgelöst. Gelegentlich ist die Ausnahme das Ergebnis eines Tippfehlers; Ein typischer Fehler besteht beispielsweise darin, "[" (die linke Klammer) anstelle von "{" (die linke Klammer) falsch einzuschlagen.
Wenn die Format(System.IFormatProvider,System.String,System.Object[])-Methode Parameterarrays unterstützt, warum löst mein Code eine Ausnahme aus, wenn ich ein Array verwende?
Der folgende Code löst beispielsweise eine Ausnahme aus FormatException :
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);
open System
let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
End Sub
End Module
Dies ist ein Problem der Compilerüberladungsauflösung. Da der Compiler ein Array ganzer Zahlen nicht in ein Objektarray konvertieren kann, behandelt er das ganzzahlige Array als einzelnes Argument, sodass er die Format(String, Object) -Methode aufruft. Die Ausnahme wird ausgelöst, da es vier Formatelemente, aber nur ein einzelnes Element in der Formatliste gibt.
Da weder Visual Basic noch C# ein ganzzahliges Array in ein Objektarray konvertieren können, müssen Sie die Konvertierung vor dem Aufrufen der Format(String, Object[]) Methode selbst ausführen. 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);
open System
let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Dim values(numbers.Length - 1) As Object
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
End Sub
End Module
Format(IFormatProvider, String, Object, Object, Object)
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 -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- String
- arg0
- Object
Das erste zu formatierende Objekt.
- arg1
- Object
Das zweite zu formatierende Objekt.
- arg2
- Object
Das dritte zu formatierende Objekt.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , um drei Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Konvertierung verwendet die Methode kultursensitive Formatierungen oder einen benutzerdefinierten Formatierer. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung, indem die ToString(IFormatProvider)- Methode aufgerufen wird, oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, indem sie die ToString(String,IFormatProvider)- Methode aufruft. 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 -> stringPublic Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As StringParameter
- format
- String
- arg0
- Object
Das erste zu formatierende Objekt.
- arg1
- Object
Das zweite zu formatierende Objekt.
- arg2
- Object
Das dritte zu formatierende Objekt.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , 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 der 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)
open System
let formatString =
" {0,10} ({0,8:X8})\nAnd {1,10} ({1,8:X8})\n = {2,10} ({2,8:X8})"
let value1 = 16932
let value2 = 15421
String.Format(formatString, value1, value2, value1 &&& value2)
|> printfn "%s"
// 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)
Weitere Informationen
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 -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- String
- arg0
- Object
Das erste zu formatierende Objekt.
- arg1
- Object
Das zweite zu formatierende Objekt.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , um zwei Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Konvertierung verwendet die Methode kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung, indem die ToString(IFormatProvider) -Methode aufgerufen wird, oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, indem die ToString(String,IFormatProvider) -Methode aufgerufen wird. Wenn diese Methoden nicht vorhanden sind, wird die parameterlose ToString-Methode des Objekts aufgerufen.
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)
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 -> stringPublic Shared Function Format (format As String, arg0 As Object, arg1 As Object) As StringParameter
- format
- String
- arg0
- Object
Das erste zu formatierende Objekt.
- arg1
- Object
Das zweite zu formatierende Objekt.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , 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 Dictionary<TKey,TValue> Objekt gespeichert sind. Beachten Sie, dass die Formatzeichenfolge drei Formatelemente enthält, obwohl nur zwei Zu formatierende Objekte vorhanden sind. 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
open System
open System.Collections.Generic
let temperatureInfo = Dictionary<DateTime, float>()
temperatureInfo.Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46)
temperatureInfo.Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81)
printfn $"Temperature Information:\n"
for item in temperatureInfo do
String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", item.Key, item.Value)
|> printfn "%s"
// 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
Weitere Informationen
- Formatieren von Typen in .NET
- Kombinierte Formatierung
- Standard-Formatzeichenfolgen für Datum und Uhrzeit
- Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit
- Standardmäßige Zahlenformatzeichenfolgen
- Benutzerdefinierte Zahlenformatzeichenfolgen
- TimeSpan-Standardformatzeichenfolgen
- Benutzerdefinierte TimeSpan-Formatzeichenfolgen
- Enumerationsformatzeichenfolgen
Gilt für:
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ReadOnlySpan<System::Object ^> args);public static string Format (IFormatProvider? provider, System.Text.CompositeFormat format, ReadOnlySpan<object?> args);static member Format : IFormatProvider * System.Text.CompositeFormat * ReadOnlySpan<obj> -> stringPublic Shared Function Format (provider As IFormatProvider, format As CompositeFormat, args As ReadOnlySpan(Of Object)) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- CompositeFormat
einen CompositeFormat
- args
- ReadOnlySpan<Object>
Eine Spanne von zu formatierenden Objekten.
Gibt zurück
Die formatierte Zeichenfolge.
Ausnahmen
format ist null
Der Index eines Formatelements ist größer oder gleich der Anzahl der angegebenen Argumente.
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 -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- String
- arg0
- Object
Das zu formatierende Objekt.
Gibt zurück
Eine Kopie von format, in der die Formatelemente durch die Zeichenfolgendarstellung von arg0 ersetzt wurden.
Ausnahmen
format ist 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 zusammengesetzte Formatierungsfunktion , um den Wert eines Ausdrucks in seine Zeichenfolgendarstellung zu konvertieren und diese Darstellung in eine Zeichenfolge einzubetten. Bei der Konvertierung verwendet die Methode kulturabhängige Formatierung oder einen benutzerdefinierten Formatierer. Die -Methode konvertiert in ihre Zeichenfolgendarstellung arg0 , indem sie ihre ToString(IFormatProvider)- Methode aufruft, oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, indem sie die ToString(String,IFormatProvider) -Methode aufruft. 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[] -> stringPublic Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- String
- args
- Object[]
Ein Objektarray mit 0 (null) oder mehr zu formatierenden Objekten.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , um vier oder mehr Ausdrücke in ihre Zeichenfolgendarstellungen zu konvertieren und diese Darstellungen in eine Zeichenfolge einzubetten. Bei der Konvertierung verwendet die Methode kultursensitive Formatierungen oder einen benutzerdefinierten Formatierer. Die -Methode konvertiert jedes Object Argument in seine Zeichenfolgendarstellung, indem die ToString(IFormatProvider)- Methode aufgerufen wird, oder, wenn das entsprechende Formatelement des Objekts eine Formatzeichenfolge enthält, indem sie die ToString(String,IFormatProvider)- Methode aufruft. 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: Kultursensitive Formatierung
In diesem Beispiel wird die Format(IFormatProvider, String, Object[]) -Methode verwendet, um die Zeichenfolgendarstellung einiger Datums- und Uhrzeitwerte und numerischer Werte unter Verwendung mehrerer unterschiedlicher 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
open System
open System.Globalization
let cultureNames = [| "en-US"; "fr-FR"; "de-DE"; "es-ES" |]
let dateToDisplay = DateTime(2009, 9, 1, 18, 32, 0)
let value = 9164.32
printfn "Culture Date Value\n"
for cultureName in cultureNames do
let culture = CultureInfo cultureName
String.Format(culture, "{0,-11} {1,-35:D} {2:N}", culture.Name, dateToDisplay, value)
|> printfn "%s"
// 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
Weitere Informationen
- DateTimeFormatInfo
- ICustomFormatter
- IFormatProvider
- NumberFormatInfo
- Formatieren von Typen in .NET
- Kombinierte Formatierung
- Standard-Formatzeichenfolgen für Datum und Uhrzeit
- Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit
- Standardmäßige Zahlenformatzeichenfolgen
- Benutzerdefinierte Zahlenformatzeichenfolgen
- TimeSpan-Standardformatzeichenfolgen
- Benutzerdefinierte TimeSpan-Formatzeichenfolgen
- Enumerationsformatzeichenfolgen
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[] -> stringPublic Shared Function Format (format As String, ParamArray args As Object()) As StringParameter
- format
- String
- args
- Object[]
Ein Objektarray mit 0 (null) oder mehr zu formatierenden Objekten.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , 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 System.ParamArrayAttribute -Attribut gekennzeichnet ist, können Sie die Objekte als einzelne Argumente oder als Object Array an die -Methode ü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 zur hohen und niedrigen 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 ihres 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)
let date1 = DateTime(2009, 7, 1)
let hiTime = TimeSpan(14, 17, 32)
let hiTemp = 62.1m
let loTime = TimeSpan(3, 16, 10)
let loTemp = 54.8m
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", date1, hiTime, hiTemp, loTime, loTemp)
|> printfn "%s\n"
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", [| date1 :> obj; hiTime; hiTemp; loTime; loTemp |])
|> printfn "%s"
// The example displays output like the following:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
Module Example
Public Sub Main()
Dim date1 As Date = #7/1/2009#
Dim hiTime As New TimeSpan(14, 17, 32)
Dim hiTemp As Decimal = 62.1d
Dim loTime As New TimeSpan(3, 16, 10)
Dim loTemp As Decimal = 54.8d
Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
Console.WriteLine(result1)
Console.WriteLine()
Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
Console.WriteLine(result2)
End Sub
End Module
' The example displays the following output:
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
'
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
Sie können die zu formatierenden Objekte auch als Array und nicht als Argumentliste übergeben.
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
open System
type CityInfo =
{ Name: string
Population: int
Area: Decimal
Year: int }
let showPopulationData city =
let args: obj[] = [| city.Name; city.Year; city.Population; city.Area |]
String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
|> printfn "%s"
{ Name = "New York"; Population = 8175133; Area = 302.64m; Year = 2010 }
|> showPopulationData
{ Name = "Seattle"; Population = 608660; Area = 83.94m; Year = 2010 }
|> showPopulationData
// 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
Weitere Informationen
- Formatieren von Typen in .NET
- Kombinierte Formatierung
- Standard-Formatzeichenfolgen für Datum und Uhrzeit
- Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit
- Standardmäßige Zahlenformatzeichenfolgen
- Benutzerdefinierte Zahlenformatzeichenfolgen
- TimeSpan-Standardformatzeichenfolgen
- Benutzerdefinierte TimeSpan-Formatzeichenfolgen
- Enumerationsformatzeichenfolgen
Gilt für:
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 -> stringPublic Shared Function Format (format As String, arg0 As Object) As StringParameter
- format
- String
- arg0
- Object
Das zu formatierende Objekt.
Gibt zurück
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 zusammengesetzte Formatierungsfunktion , 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 -Methode verwendet, um das Format(String, Object) 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.
let birthdate = DateTime(1993, 7, 28)
let dates =
[ DateTime(1993, 8, 16)
DateTime(1994, 7, 28)
DateTime(2000, 10, 16)
DateTime(2003, 7, 27)
DateTime(2007, 5, 27) ]
for dateValue in dates do
let interval = dateValue - birthdate
// Get the approximate number of years, without accounting for leap years.
let years = (int interval.TotalDays) / 365
// See if adding the number of years exceeds dateValue.
if birthdate.AddYears years <= dateValue then
String.Format("You are now {0} years old.", years)
else
String.Format("You are now {0} years old.", years - 1)
|> printfn "%s"
// 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.
Weitere Informationen
- Formatieren von Typen in .NET
- Kombinierte Formatierung
- Standard-Formatzeichenfolgen für Datum und Uhrzeit
- Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit
- Standardmäßige Zahlenformatzeichenfolgen
- Benutzerdefinierte Zahlenformatzeichenfolgen
- TimeSpan-Standardformatzeichenfolgen
- Benutzerdefinierte TimeSpan-Formatzeichenfolgen
- Enumerationsformatzeichenfolgen
Gilt für:
Format(IFormatProvider, CompositeFormat, Object[])
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ... cli::array <System::Object ^> ^ args);public static string Format (IFormatProvider? provider, System.Text.CompositeFormat format, params object?[] args);static member Format : IFormatProvider * System.Text.CompositeFormat * obj[] -> stringPublic Shared Function Format (provider As IFormatProvider, format As CompositeFormat, ParamArray args As Object()) As StringParameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- CompositeFormat
einen CompositeFormat
- args
- Object[]
Ein Array zu formatierender Objekte.
Gibt zurück
Die formatierte Zeichenfolge.
Ausnahmen
format oder args ist null.
Der Index eines Formatelements ist größer oder gleich der Anzahl der angegebenen Argumente.
Gilt für:
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format.
public:
generic <typename TArg0, typename TArg1, typename TArg2>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1, TArg2 arg2);public static string Format<TArg0,TArg1,TArg2> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1, TArg2 arg2);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 * 'TArg2 -> stringPublic Shared Function Format(Of TArg0, TArg1, TArg2) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1, arg2 As TArg2) As StringTypparameter
- TArg0
Der Typ des ersten zu formatierenden Objekts.
- TArg1
Der Typ des zweiten zu formatierenden Objekts.
- TArg2
Der Typ des dritten zu formatierenden Objekts.
Parameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- CompositeFormat
einen CompositeFormat
- arg0
- TArg0
Das erste zu formatierende Objekt.
- arg1
- TArg1
Das zweite zu formatierende Objekt.
- arg2
- TArg2
Das dritte zu formatierende Objekt.
Gibt zurück
Die formatierte Zeichenfolge.
Ausnahmen
format ist null
Der Index eines Formatelements ist größer oder gleich der Anzahl der angegebenen Argumente.
Gilt für:
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format.
public:
generic <typename TArg0, typename TArg1>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1);public static string Format<TArg0,TArg1> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 -> stringPublic Shared Function Format(Of TArg0, TArg1) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1) As StringTypparameter
- TArg0
Der Typ des ersten zu formatierenden Objekts.
- TArg1
Der Typ des zweiten zu formatierenden Objekts.
Parameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- CompositeFormat
einen CompositeFormat
- arg0
- TArg0
Das erste zu formatierende Objekt.
- arg1
- TArg1
Das zweite zu formatierende Objekt.
Gibt zurück
Die formatierte Zeichenfolge.
Ausnahmen
format ist null
Der Index eines Formatelements ist größer oder gleich der Anzahl der angegebenen Argumente.
Gilt für:
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)
Ersetzt das Formatelement bzw. die Elemente in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format.
public:
generic <typename TArg0>
static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0);public static string Format<TArg0> (IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0);static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 -> stringPublic Shared Function Format(Of TArg0) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0) As StringTypparameter
- TArg0
Der Typ des ersten zu formatierenden Objekts.
Parameter
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- format
- CompositeFormat
einen CompositeFormat
- arg0
- TArg0
Das erste zu formatierende Objekt.
Gibt zurück
Die formatierte Zeichenfolge.
Ausnahmen
format ist null
Der Index eines Formatelements ist größer oder gleich der Anzahl der angegebenen Argumente.
Gilt für:
Feedback
Feedback senden und anzeigen für