Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

String.Format-Methode

 

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

Wenn Sie noch nicht mit sind die String.Format -Methode finden Sie unter derEinstieg in die String.Format-Methode Abschnitt, um eine kurze Übersicht über.

Finden Sie unter der "Hinweise" Abschnitt für die vollständige Dokumentation aller String.Format Überladungen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

NameBeschreibung
System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

Ersetzt ein oder mehrere Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object[])

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

Verwendung String.Format , wenn den Wert eines Objekts, eine Variable oder ein Ausdruck in eine andere Zeichenfolge eingefügt werden müssen. Sie können beispielsweise den Wert des Einfügen einer Decimal Wert in eine Zeichenfolge, die es dem Benutzer als einzelne Zeichenfolge anzuzeigen:

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
// Result: The current price is 17.36 per ounce.

Und Sie können die Formatierung des Werts steuern:

Decimal pricePerOunce = 17.36m;
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.

Neben dem formatieren, können Sie auch die Ausrichtung und Abstand steuern.

Eine Zeichenfolge eingefügt.

String.Formatbeginnt mit einer Formatzeichenfolge, gefolgt von Objekten oder Ausdrücke, die in Zeichenfolgen konvertiert und an einem angegebenen Speicherort gespeichert, in der Formatzeichenfolge eingefügt werden. Zum Beispiel:

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

Die {0} im Format Zeichenfolge eines Formatelements ist. 0ist der Index des Objekts, dessen Zeichenfolgenwert an dieser Position eingefügt werden soll. (Indizes beginnen bei 0.) Wenn das einzufügende Objekt nicht um eine Zeichenfolge ist ihre ToString Methode wird aufgerufen, um es zu einem vor dem Einfügen in die Ergebniszeichenfolge konvertieren.

Hier ist 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.'

Sie können beliebig viele Formatelemente und wie viele Objekte in der Objektliste, wie Sie möchten, solange der Index der jedes Formatelement kein übereinstimmendes Objekt in der Objektliste verfügt. Ferner müssen nicht Gedanken machen, rufen Sie über die Überlastung; der Compiler wird für Sie ausgewählt.

Steuern der Formatierung

Führen Sie den Index in einem Formatelement mit einer Formatzeichenfolge steuern, wie ein Objekt formatiert ist. Beispielsweise {0:d} betrifft die Formatzeichenfolge "d" das erste Objekt in der Objektliste. Hier ist ein Beispiel mit einem einzelnen Objekt und zwei Elemente formatieren:

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'

Eine Anzahl von Typen unterstützen Formatzeichenfolgen, einschließlich aller numerische Typen (sowohl standard und benutzerdefinierte -Formatzeichenfolgen für), alle Datums- und Uhrzeitangaben (sowohl standard und benutzerdefinierte Formatzeichenfolgen) und Zeitintervalle (beide standard und benutzerdefinierte -Formatzeichenfolgen für), alle Enumerationstypen Enumerationstypen, und GUIDs. Sie können auch Unterstützung für Formatzeichenfolgen für Ihre eigenen Typen hinzufügen.

Steuern der Abstand

Sie können die Breite der Zeichenfolge, die in die Ergebniszeichenfolge eingefügt wird, wie z. B. mit der Syntax definieren {0,12}, eine Zeichenfolge mit 12 Zeichen eingefügt. In diesem Fall wird die Zeichenfolgendarstellung des ersten Objekts rechtsbündig im Feld 12 Zeichen. (Ist die Zeichenfolgendarstellung des ersten Objekts maximal 12 Zeichen lang sein, jedoch die bevorzugte Feldbreite wird ignoriert, und die gesamte Zeichenfolge wird in die Ergebniszeichenfolge eingefügt.)

Das folgende Beispiel definiert ein Feld 6 Zeichen zum Speichern der Zeichenfolge "Year" und einige Jahr Zeichenfolgen, sowie ein Feld 15-Zeichen für die Zeichenfolge "Auffüllung" und einige Daten auffüllen. Beachten Sie, dass die Zeichen rechtsbündig in das Feld.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,6} {1,15}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{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
Steuern der Ausrichtung

Standardmäßig werden Zeichenfolgen in ihren Feld rechtsbündig ausgerichtet, wenn Sie eine Feldbreite anzugeben. Um Zeichenfolgen in einem Feld linksbündig, Sie voranstellen die Feldbreite ein negatives Vorzeichen, z. B. {0,-12} so definieren Sie einen 12-stelligen-Feld rechtsbündig ausgerichtet.

Im folgende Beispiel ähnelt der vorherigen Abfrage, außer dass sie sowohl Daten als auch Bezeichnungen linksbündig ausgerichtet.

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]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

String.FormatVerwenden der Funktion für kombinierte Formatierung. Weitere Informationen finden Sie unter Kombinierte Formatierung.

Weitere Anleitungen zum Auswählen einer Überladung finden Sie unter welche Methode aufrufen?

String String.Format(String format, Object arg0)

Ersetzt die Formatelemente durch die Zeichenfolgendarstellung eines angegebenen Objekts (Beispiel).

String String.Format(String format, Object arg0, Object arg1)

Ersetzt die Formatelemente durch die Zeichenfolgendarstellung von zwei angegebenen Objekten (Beispiel).

String String.Format(String format, Object arg0, Object arg1, Object arg2)

Ersetzt die Formatelemente durch die Zeichenfolgendarstellung von drei angegebenen Objekten (Beispiel).

String String.Format(String format, params Object[] args)

Ersetzt die Formatelemente durch die zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array (Beispiel).

String String.Format(IFormatProvider provider, String format, params Object[] args)

Ersetzt die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Objekte in einem angegebenen Array und der angegebenen kulturspezifischen Formatierungsinformationen verwendet (Beispiel) oder benutzerdefinierte Formatierung Informationen (Beispiel).

Dies ist eine vollständige Liste der Parameter für die Format -Methode; Weitere Informationen finden Sie die Syntax der Überladung oben für die Parameter, die durch jede Überladung verwendet. Nur die format Parameter wird verwendet, indem Sie alle Überladungen.

Parameter

Typ

Beschreibung

format

String

Eine kombinierte Formatzeichenfolge, die eine oder mehrere Formatelemente enthält (siehe das Formatelement).

arg0

String

Der erste oder nur zu formatierende Objekt.

arg1

String

Das zweite zu formatierende Objekt.

arg2

String

Das dritte zu formatierende Objekt.

args

String[]

NULL oder mehr Objekte zum Formatieren in einer durch Trennzeichen getrennte Liste oder als Array angegeben.

provider

IFormatProvider

Ein Objekt, das benutzerdefinierte oder kulturspezifische Formatierungsinformationen bereitstellt.

Typ: String
eine Kopie des format in der die Formatelemente durch die Zeichenfolgendarstellung der entsprechenden Argumente ersetzt wurden.

Ausnahme

Bedingung

Ausgelöst von

ArgumentNullException

format ist null.

Alle Überladungen.

FormatException

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als 0 oder größer als oder gleich der Anzahl von Argumenten in der Argumentliste.

Alle Überladungen.

Beschreibung

Call

Ein oder mehrere Objekte mit den Konventionen der aktuellen Kultur zu formatieren.

Mit Ausnahme der Überladungen, die eine provider Parameter, die verbleibendenFormat Überladungen enthalten einen String Parameter gefolgt von mindestens einem Objektparameter. Aus diesem Grund Sie keine ermitteln, welche Format Überladung, die Sie aufrufen möchten. Der Sprachcompiler wählt die entsprechende Überladung aus der Überladungen, die keine provider basierend auf Ihrer Typargumentliste-Parameter. Z. B. Wenn Sie Ihrer Typargumentliste fünf Argumente verfügt, der Compiler Ruft die Format(String, Object[]) Methode.

Ein oder mehrere Objekte mit den Konventionen einer bestimmten Kultur zu formatieren.

JedeFormatÜberladung, die mit beginnt ein provider Parameter gefolgt von einer String Parameter und mindestens einen Parameter-Objekt. Aus diesem Grund Sie keine um zu bestimmen, welche spezifischen Format Überladung, die Sie aufrufen möchten. Der Sprachcompiler wählt die entsprechende Überladung aus der Überladungen, die über eine provider basierend auf Ihrer Typargumentliste-Parameter. Z. B. Wenn Sie Ihrer Typargumentliste fünf Argumente verfügt, der Compiler Ruft die Format(IFormatProvider, String, Object[]) Methode.

Führen Sie einem benutzerdefinierten Formatierungsvorgang eine mit einer ICustomFormatter Implementierung oder ein IFormattable Implementierung.

Einer der vier Überladungen mit einem provider Parameter. Compiler wählt die entsprechende Überladung aus der Überladungen, die über eine provider basierend auf Ihrer Typargumentliste-Parameter.

Jeder Überladung der Format -Methode verwendet die Funktion für kombinierte Formatierung nullbasierte indizierte Platzhaltern, so genannten Formatelementen, in eine zusammengesetzte Formatzeichenfolge eingeschlossen. Jedes Formatelement wird zur Laufzeit durch die Zeichenfolgendarstellung des entsprechenden Arguments in einer Parameterliste ersetzt. Wenn der Wert des Arguments null, ersetzt das Formatelement mit String.Empty. Beispielsweise beim folgenden Aufruf der Format(String, Object, Object, Object) Methode enthält eine Formatzeichenfolge mit drei Formatelemente, {0}, \ {1\}, \ {2\} und eine Liste der Typargumente mit drei Elementen.

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 the following output:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   

Einem Formatelement hat folgende Syntax:


{
index[,alignment][ :formatString] }

Klammern bezeichnen optionale Elemente. Die öffnende und schließende geschweifte Klammern sind erforderlich. (Um enthalten eine literale öffnende bzw. schließende geschweifte Klammer in der Formatzeichenfolge finden im Abschnitt "Geschweiften Klammern mit Escapezeichen zu versehen" die Kombinierte Formatierung Artikel.)

Beispielsweise die einem Formatelement in das Format, die ein Currency-Wert kann wie folgt angezeigt:

String.Format("{0,-10:C}", 126347.89m);         

Einem Formatelement beinhaltet die folgenden Elemente:

Index

Der nullbasierte Index des Arguments, dessen zeichenfolgedarstellung werden an dieser Position in der Zeichenfolge enthalten. Wenn dieses Argument null, keine leere Zeichenfolge wird an dieser Position in der Zeichenfolge enthalten sein.

Ausrichtung

Optional. Eine Ganzzahl mit Vorzeichen, die die Gesamtlänge des Felds angibt, in der das Argument eingefügt wird und ob sie rechtsbündig (eine positive ganze Zahl) oder linksbündig ausgerichtet (eine negative ganze Zahl). Wenn Sie weglassen Ausrichtung, die Zeichenfolgendarstellung des entsprechenden Arguments in einem Feld keine führenden oder nachgestellten Leerzeichen eingefügt wird.

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

"FormatString"

Dies ist optional. Eine Zeichenfolge, die das Format der Ergebniszeichenfolge das entsprechende Argument angibt. Wenn Sie weglassen "FormatString", das entsprechende Argument des parameterlosen ToString Methode wird aufgerufen, um die Zeichenfolgendarstellung zu erzeugen. Bei Angabe von "FormatString", muss das Argument, das Formatelement verweist implementieren die IFormattable Schnittstelle. Die Formatzeichenfolgen unterstützen die folgenden Anweisungstypen:

Beachten Sie jedoch, dass jeder beliebige benutzerdefinierter Typ implementieren, kann IFormattable oder Erweitern eines vorhandenen Typs IFormattable Implementierung.

Im folgenden Beispiel wird die alignment und formatString Argumente formatierte Ausgabe zu erzeugen.

using System;

public class Example
{
   public static void Main()
   {
      // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Tuple<string, DateTime, int, DateTime, int>[] cities = 
          { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                         new DateTime(1950, 1, 1), 1970358),
            Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                         new DateTime(1950, 1, 1), 7891957),  
            Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                         new DateTime(1950, 1, 1), 3620962),  
            Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                         new DateTime(1950, 1, 1), 1849568) };

      // Display header
      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;      
      foreach (var 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 %

Formatelement werden sequenziell vom Anfang der Zeichenfolge verarbeitet. Jedes Formatelement verfügt über einen Index, der ein Objekt in der Argumentliste der Methode entspricht. Die Format Methode ruft das Argument und seine Zeichenfolgendarstellung wie folgt abgeleitet:

  • Wenn das Argument ist null, fügt die Methode String.Empty in der Ergebniszeichenfolge.

  • Beim Aufrufen der Format(IFormatProvider, String, Object[]) überladen und die provider -Parameter implementiert die ICustomFormatter -Schnittstelle, wird das Argument zu übergeben der provider des Objekts ICustomFormatter.Format(String, Object, IFormatProvider) Methode. Wenn die Formatelement enthält eine "FormatString" Argument, es wird als erstes Argument an die Methode übergeben. Wenn die ICustomFormatter Implementierung kann Formatierung Dienstleistungen, es gibt die Zeichenfolgendarstellung des Arguments zurück; zurückgegeben, andernfalls null und der nächste Schritt ausgeführt wird.

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

  • Das Argument des parameterlosen ToString -Methode, die überschrieben oder geerbt von der Object Klasse, die aufgerufen wird.

Ein Beispiel für die Aufrufe fängt die ICustomFormatter.Format Methode und ermöglicht Ihnen, welche Informationen finden Sie unter der Format -Methode übergibt, einer Formatierungsmethode für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge finden Sie unter Beispiel 7: einen Intercept-Anbieter und römische Zahlzeichen Formatierer.

Die Format -Methode löst eine FormatException -Ausnahme aus, wenn der Index eines Elements Index größer als oder gleich der Anzahl von Argumenten in der Argumentliste ist. Allerdings format zählen mehr Formatelementen, die als Argumente vorhanden sind, solange mehrere Formatelemente denselben Index verfügen. Im Aufruf der Format(String, Object) Methode im folgenden Beispiel wird die Liste der Typargumente hat ein einzelnes Argument, aber die Formatzeichenfolge enthält zwei Formatelemente: eine zeigt den Dezimalwert einer Zahl und das andere seinem Hexadezimalwert.

public class Example
{
   public static void Main()
   {
      short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
      Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
      foreach (short value in values)
      {
         string formatString = String.Format("{0,10:G}: {0,10:X}", value);
         Console.WriteLine(formatString);
      }   
   }
}
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

Im Allgemeinen Objekte in der Argumentliste mit den Konventionen der aktuellen Kultur, die von zurückgegeben wird, deren zeichenfolgendarstellungen konvertiert werden die CultureInfo.CurrentCulture Eigenschaft. Sie können dieses Verhalten steuern, indem eine der Überladungen der Aufrufen Format , umfasst eine provider Parameter. Die provider Parameter ist ein IFormatProvider Implementierung, die benutzerdefinierte und kulturspezifische Formatierungsinformationen bereitstellt, die verwendet wird, um die Formatierung Mittel zu verarbeiten.

Die IFormatProvider Schnittstelle verfügt über einen einzelnen Member, GetFormat, die für das Objekt, das Formatierungsinformationen liefert zurückgeben verantwortlich ist. .NET Framework verfügt über drei IFormatProvider Implementierungen, die kulturspezifische Formatierung bereitstellen:

Sie können auch eine der Überladungen der Aufrufen der Format -Methode, die über eine provider Parameter Format(IFormatProvider, String, Object[]) Überladung, um die benutzerdefinierte Formatierung Vorgänge auszuführen. Sie konnten z. B. eine ganze Zahl als eine ID oder eine Telefonnummer formatieren. Benutzerdefinierte Formatierung Ausführen Ihrer provider Argument muss sowohl implementieren die IFormatProvider und ICustomFormatter Schnittstellen. Wenn dieFormat -Methode übergeben ein ICustomFormatter Implementierung als die provider Argument, die Format Methodenaufrufe seine IFormatProvider.GetFormat Implementierung und fordert ein Objekt vom Typ ICustomFormatter. Er ruft dann das zurückgegebene ICustomFormatter des Objekts Format Methode so formatieren Sie jedes Formatelement in der zusammengesetzte Zeichenfolge übergeben.

Weitere Informationen zum Bereitstellen von Lösungen für benutzerdefinierte Formatierung finden Sie unter Gewusst wie: Definieren und Verwenden von benutzerdefinierten numerischen Formatanbietern und ICustomFormatter. Ein Beispiel für die ganze Zahlen in formatierte benutzerdefinierte Zahlen umwandelt, finden Sie unter Beispiel 6: eine benutzerdefinierte Formatierungsvorgang. Ein Beispiel, das römische Ziffern Bytes ohne Vorzeichen konvertiert werden, finden Sie unter Beispiel 7: einen Intercept-Anbieter und römische Zahlzeichen Formatierer.

Im folgenden Beispiel wird die Format(String, Object) Methode, um ein einzelnes Alter in der Mitte einer Zeichenfolge einzubetten.

using System;

[assembly: CLSCompliant(true)]
public class Example
{
   public static void Main()
   {
      DateTime birthdate = new DateTime(1993, 7, 28);
      DateTime[] dates = { new DateTime(1993, 8, 16), 
                           new DateTime(1994, 7, 28), 
                           new DateTime(2000, 10, 16), 
                           new DateTime(2003, 7, 27), 
                           new DateTime(2007, 5, 27) };

      foreach (DateTime dateValue in dates)
      {
         TimeSpan interval = dateValue - birthdate;
         // Get the approximate number of years, without accounting for leap years.
         int years = ((int) interval.TotalDays) / 365;
         // See if adding the number of years exceeds dateValue.
         string output;
         if (birthdate.AddYears(years) <= dateValue) {
            output = String.Format("You are now {0} years old.", years);
            Console.WriteLine(output);
         }   
         else {
            output = String.Format("You are now {0} years old.", years - 1);
            Console.WriteLine(output);
         }      
      }
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.

Dieses Beispiel verwendet die Format(String, Object, Object) anzuzeigenden Zeit und die Temperatur Datenspeichern in eine generische Methode Dictionary<TKey, TValue> Objekt. Beachten Sie, dass die Formatzeichenfolge drei Formatelemente, obwohl nur zwei Objekte so formatieren Sie vorhanden sind. Ursache hierfür ist das erste Objekt in der Liste (ein Wert für Datum und Uhrzeit) durch zwei Formatelementen verwendet wird: das erste Format Element zeigt die Zeit, während die zweite zeigt das Datum an.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
      temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
      temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

      Console.WriteLine("Temperature Information:\n");
      string output;   
      foreach (var item in temperatureInfo)
      {
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                                item.Key, item.Value);
         Console.WriteLine(output);
      }
   }
}
// The example displays 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

Dieses Beispiel verwendet die Format(String, Object, Object, Object) Methode, um eine Zeichenfolge zu erstellen, die das Ergebnis ein boolescher Wert veranschaulicht And -Operation mit zwei ganzzahligen Werten. Beachten Sie, dass die Formatzeichenfolge sechs Formatelemente enthält, aber die Methode verfügt über nur drei Elemente in der Parameterliste, da jedes Element auf zwei unterschiedliche Arten formatiert wird.

using System;

public class Example
{
   public static void Main()
   {
      string formatString = "    {0,10} ({0,8:X8})\n" + 
                            "And {1,10} ({1,8:X8})\n" + 
                            "  = {2,10} ({2,8:X8})";
      int value1 = 16932;
      int value2 = 15421;
      string result = String.Format(formatString, 
                                    value1, value2, value1 & value2);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)

Dieses Beispiel erstellt eine Zeichenfolge, die Daten auf den Höchst- und Tiefsttemperatur an einem bestimmten Datum enthält. Die zusammengesetzte Formatierungszeichenfolge verfügt über fünf Formatelemente im C#-Beispiel und sechs in Visual Basic-Beispiel. Zwei der die Formatelemente definieren die Breite der Zeichenfolgendarstellung des Werts auf ihre entsprechenden, und das erste Formatelement enthält auch Standardformatbezeichner für Datum und Uhrzeit-Formatzeichenfolge.

using System;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 7, 1);
      TimeSpan hiTime = new TimeSpan(14, 17, 32);
      decimal hiTemp = 62.1m; 
      TimeSpan loTime = new TimeSpan(3, 16, 10);
      decimal loTemp = 54.8m; 

      string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                     date1, hiTime, hiTemp, loTime, loTemp);
      Console.WriteLine(result1);
      Console.WriteLine();

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

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

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

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

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };

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

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

In diesem Beispiel definiert einen Formatanbieter, der einen ganzzahligen Wert als die Kontonummer eines Kunden in der Form X-Xxxxx-Xx formatiert.

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.

In diesem Beispiel wird einen benutzerdefiniertes Format-Anbieter, implementiert die ICustomFormatter und IFormatProvider Schnittstellen zwei Dinge tun:

  • Es zeigt die Parameter, dessen ICustomFormatter.Format Implementierung. Dies ermöglicht es, zu welchen Parameter finden Sie unter der Format(IFormatProvider, String, Object[]) Methode für die benutzerdefinierte Formatierung Implementierung für jedes Objekt, das er versucht, formatieren Sie übergeben wird. Dies kann nützlich sein, wenn Sie Ihre Anwendung debuggen.

  • Wenn das Objekt zu formatierenden ein Byte ohne Vorzeichen-Wert, der mit der Standardformatzeichenfolge "R" formatiert werden, formatiert das benutzerdefinierte Formatierungsprogramm den numerischen Wert als eine römische Zahlzeichen an.

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, 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

.NET Framework

Alle Überladungen werden unterstützt: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Alle Überladungen werden unterstützt: 4, 3.5 SP1

Portable Klassenbibliothek

Nur Format(String, Object[]) und Format(IFormatProvider, String, Object[]) werden unterstützt

.NET für Windows Store-Apps

Nur Format(String, Object[]) und Format(IFormatProvider, String, Object[]) in Windows 8 unterstützt werden

Die allgemeine Syntax eines Formatelements ist:

{index[,alignment][: formatString]}

wobei Ausrichtung ist eine Ganzzahl mit Vorzeichen, die die Breite des Felds definiert. Wenn dieser Wert negativ ist, wird Text im Feld linksbündig ausgerichtet. Wenn er positiv ist, ist Text rechtsbündig ausgerichtet.

Alle standardmäßige numerische Formatzeichenfolgen außer "D" (die mit nur ganze Zahlen verwendet wird), "G", "R" und "X" ermöglichen ein Genauigkeitsbezeichner angegeben, die die Anzahl von Dezimalstellen in der Ergebniszeichenfolge definiert. Im folgenden Beispiel wird die standardmäßige numerische Formatzeichenfolgen, die Anzahl der Dezimalstellen in der Ergebniszeichenfolge steuern.

using System;

public class Example
{
   public static void Main()
   {
      object[] values = { 1603, 1794.68235, 15436.14 };
      string result;
      foreach (var value in values) {
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                                Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
         Console.WriteLine(result);
      }                           
   }
}
// The example displays the following output:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Bei Verwendung einer benutzerdefinierte numerische Formatzeichenfolge, den Formatbezeichner "0" zum Steuern der Anzahl von Dezimalstellen in der Ergebniszeichenfolge an, wie im folgenden Beispiel gezeigt verwenden.

using System;

public class Example
{
   public static void Main()
   {
      decimal value = 16309.5436m;
      string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

Standardmäßig werden Formatierungsvorgänge nur ganze Zahlen ungleich 0 (null) angezeigt. Wenn Sie ganze Zahlen formatieren, können Sie ein Genauigkeitsbezeichner angegeben, mit der "D" und "X" standard verwendete Formatzeichenfolgen, die Anzahl der Ziffern steuern.

using System;

public class Example
{
   public static void Main()
   {
      int value = 1326;
      string result = String.Format("{0,10:D6} {0,10:X8}", value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//     001326   0000052E

Sie können eine ganze Zahl oder Gleitkommazahl mit führenden Nullen, um eine Ergebniszeichenfolge, die mit einer angegebenen Anzahl von ganzzahligen Ziffern zu erstellen, indem Sie mit dem Wert "0" Auffüllen benutzerdefinierte numerische Formatbezeichner, wie das folgende Beispiel zeigt.

using System;

public class Example
{
   public static void Main()
   {
      int value = 16342;
      string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

Es gibt keine praktische Begrenzung. Der zweite Parameter von der Format(IFormatProvider, String, Object[]) Methode wird mit markiert die ParamArrayAttribute -Attribut, das Ihnen ermöglicht, eine durch Trennzeichen getrennte Liste oder einem Objektarray als Ihrer Formatliste enthalten.

Z. B. wie Sie, dass die folgenden Methodenaufruf aus Auslösen einer FormatException Ausnahme?

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

Eine einzelne öffnende oder schließende geschweifte Klammer wird immer als Anfang oder Ende eines Formatelements interpretiert. Um als Zeichenliteral interpretiert werden, müssen sie mit Escapezeichen versehen werden. Sie eine geschweifte Klammer durch Hinzufügen von einem anderen geschweifte Klammer mit Escapezeichen versehen ("{{" und "}}" anstelle von "{" und "}"), wie im folgenden Methodenaufruf:

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

Geschweifte Klammern selbst mit Escapezeichen sind jedoch leicht fehlinterpretiert. Es wird empfohlen, dass Sie die geschweiften Klammern, in der Formatliste einschließen und Formatelemente zum Einfügen in die Ergebniszeichenfolge wie im folgenden Beispiel gezeigt verwenden.

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

Die häufigste Ursache der Ausnahme ist, dass der Index eines Formatelements ein Objekt in der Formatliste entsprechen nicht. In der Regel bedeutet dies, dass haben Sie die Indizes der Formatelemente misnumbered, oder Sie vergessen haben, ein Objekt in der Formatliste enthalten. In einigen Fällen ist die Ausnahme das Ergebnis ein Tippfehler; Angenommen, ein typische Fehler falsch ist "[" (die öffnende spitze Klammer) anstelle von "{" (die linke geschweifte Klammer).

Im folgenden Codebeispiel löst eine FormatException Ausnahme:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers);   
   }
}

Dies ist ein Problem der Compiler überladungsauflösung gelten. Da der Compiler ein Array von Ganzzahlen in einem Objektarray konvertieren kann, behandelt das Array von Ganzzahlen als ein einziges Argument, damit aufruft die Format(String, Object) Methode. Die Ausnahme wird ausgelöst, da es vier Formatelemente aber nur ein einzelnes Element in der Formatliste gibt.

Da weder Visual Basic oder c# ein Array von Ganzzahlen in einem Objektarray konvertieren kann, müssen Sie die Konvertierung ausführen selbst vor dem Aufruf der Format(String, Object[]) Methode. Im folgende Beispiel stellt eine Implementierung bereit.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      object[] values = new object[numbers.Length];
      numbers.CopyTo(values, 0);
      Console.WriteLine("{0} + {1} + {2} = {3}", values);   
   }
}
Zurück zum Anfang
Anzeigen: