(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

String.Format-Methode

Ersetzt jedes Formatelement in einer angegebenen Zeichenfolge durch den Text, der dem Wert eines entsprechenden Objekts entspricht.

Dieser Member wird überladen. Klicken Sie auf einen Namen in der Überladungsliste, um vollständige Informationen zu diesem Member sowie zu Syntax, Nutzung und Beispielen zu erhalten.

  Name Beschreibung
Öffentliche Methode Statischer Member Format(String, Object) Ersetzt ein oder mehrere Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.
Öffentliche Methode Statischer Member Format(String, Object[]) Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.
Öffentliche Methode Statischer Member Format(IFormatProvider, String, Object[]) Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturabhängige Formatierungsinformationen.
Öffentliche Methode Statischer Member Format(String, Object, Object) Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.
Öffentliche Methode Statischer Member Format(String, Object, Object, Object) Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.
Zum Seitenanfang

In diesem Abschnitt

Syntax der überladenen Methode
Parameter
Rückgabewert
Ausnahmen
Welche Methode erhalte ich auf?
Die Formatmethode in Kürze
Das Formatelement
Wie Argumente formatiert werden
Formatelementen, die denselben Index verfügen
Formatieren und Kultur
Benutzerdefinierte Formatierungsvorgänge
Beispiele:
       Stil eines einzelnen Arguments
       Formatieren von zwei Argumenten
       Formatieren von drei Argumenten
       Formatieren von mehr als drei Argumenten
       Kulturabhängige Formatierung
       Ein benutzerdefinierter Formatierungsvorgang
       Ein Abfanganbieter und ein Formatierungsprogramm der römischen Zahl
Versionsinformationen

Syntax der überladenen Methode

Zusätzliche Hinweise zum Auswählen einer Überladung finden Sie unter Welche Methode erhalte ich auf?

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 Zeichenfolgenentsprechungen entsprechender Objekte in einem angegebenen Array (Beispiel).

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

Ersetzt die Formatelemente durch die Zeichenfolgendarstellung von entsprechenden Objekte in einem angegebenen Array und verwendet die angegebenen kulturspezifische Formatierungsinformationen (Beispiel) oder in den benutzerdefinierten Formatierungsinformationen (Beispiel).

Parameter

Dies ist eine vollständige Liste von Parametern für die Format-Methode; finden Sie die Überladungssyntax oben für die Parameter, die von jeder Überladung verwendet werden. Nur dem Parameter format wird durch alle Überladungen verwendet.

Parameter

Typ

Beschreibung

s

String

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

arg0

String

Das erste oder nur das Objekt zum Formatieren.

arg1

String

Das zweite zu formatierende Objekt.

arg2

String

Das dritte zu formatierende Objekt.

args

String []

Beliebige Objekte dem Stil, angegeben entweder in einer durch Trennzeichen getrennten Liste oder als Array.

provider

IFormatProvider

Ein Objekt, das die benutzerdefinierte oder kulturspezifische Formatierungsinformationen bereitstellt.

Rückgabewert

Typ: String
Eine Kopie von format, in der die durch Zeichenfolgenentsprechungen Formatelemente der entsprechenden Argumente ersetzt wurden.

Ausnahmen

Ausnahme

Bedingung

Vorbei ausgelöst

ArgumentNullException

format ist null.

Alle Überladungen.

FormatException

format ist ungültig.

- oder -

Der Index eines Formatelements ist kleiner als null oder größer oder gleich der Anzahl der Argumente in der Argumentliste.

Alle Überladungen.

Welche Methode erhalte ich auf?

Zum

Call

Formatieren Sie ein oder mehrere Objekte, indem Sie die Konventionen der aktuellen Kultur verwenden.

Neben der Überladung, die einen provider-Parameter einschließt, enthalten alle Format Überladungen einen Parameter String, der von einer oder mehreren Objektparametern folgt. Daher müssen Sie Format nicht festlegen, welche Überladung Sie beabsichtigen, aufzurufen. Sprachcompiler das wählt die entsprechende Überladung mit den Überladungen, die keinen provider-Parameter, auf Grundlage der Argumentliste aus. Wenn die Argumentliste fünf Argumente enthält, ruft der Compiler die Format(String, Object[])-Methode auf.

Formatieren Sie ein oder mehrere Objekte, mit den Konventionen einer bestimmten Kultur verwenden.

Format(IFormatProvider, String, Object[])

Ausführen eines benutzerdefinierten Formatierungsvorgang entweder mit einer ICustomFormatter-Implementierung oder einer IFormattable-Implementierung aus.

Format(IFormatProvider, String, Object[])

Die Formatmethode in Kürze

Jede Überladung der Format-Methode verwendet Feature für die kombinierte Formatierung, um den nullbasierten indizierten Platzhalter einbindet, so genannten Formatelementen, in einer zusammengesetzten Formatzeichenfolge. Zur Laufzeit wird jedes Formatelement durch die Zeichenfolgendarstellung des entsprechenden Arguments in einer Parameterliste ersetzt. Wenn der Wert des Arguments null, wird das Formatelement durch String.Empty ersetzt. Beispielsweise enthält der folgende Aufruf der Format(String, Object, Object, Object)-Methode eine Formatzeichenfolge mit drei Formatelementen, {0} {1,}, {2} und, und einer Argumentliste 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.   


Das Formatelement

Ein Formatelement hat diese Syntax:

{ index[,alignment][ :formatString] }

Klammern sind optionale Elemente. Die Start- und die schließende Klammer erforderlich. (Eine literale öffnende bzw. schließende geschweifte Klammer in der Formatzeichenfolge einzuschließen, finden Sie im Abschnitt "entweichend geschweiften Klammern" im Artikel Kombinierte Formatierung .)

Beispielsweise wird ein Formatelement so formatiert, um einen Währungswert darzustellen:


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


Ein Formatelement weist folgende Elemente:

Index

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

alignment

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

Formatzeichenfolge

Optional. Eine Zeichenfolge, die das Format der Ergebniszeichenfolge entsprechenden des Arguments angibt. Wenn Sie Formatzeichenfolge weglassen, wird die entsprechende Methode des Arguments parameterlose ToString aufgerufen, um die Zeichenfolgendarstellung zu erzeugen. Wenn Sie Formatzeichenfolge angeben, muss das Argument, das durch das Formatelement verwiesen wird, die IFormattable-Schnittstelle implementieren. Typen, die Stützformatzeichenfolgeneinschließung:

Beachten Sie jedoch, dass ein benutzerdefinierter Typ IFormattable implementieren oder IFormattable Implementierung vorhandener Typ erweitern kann.

Im folgenden Beispiel wird die alignment und formatString ) Argumente zu formatierten Ausgabe.


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 %


Wie Argumente formatiert werden

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

  • Wenn das Argument null hat, wird die Methode String.Empty in die Ergebniszeichenfolge ein.

  • Wenn Sie die Format(IFormatProvider, String, Object[])-Überladung aufrufen und provider der Parameter die ICustomFormatter-Schnittstelle implementiert, ist das Argument der providerICustomFormatter.Format(String, Object, IFormatProvider)-Methode des Objekts übergeben. Wenn das Formatelement ein Formatzeichenfolge-Argument enthält, wird es als das erste Argument an die Methode übergeben. Wenn die ICustomFormatter Implementierung in der Lage ist, Formatierungsdienste bereitzustellen, wird die Zeichenfolgendarstellung des Arguments zurück; Andernfalls wird null zurückgegeben und der nächste Schritt ausgeführt.

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

  • Die parameterlose ToString-Methode des Arguments, die von der Object-Klasse überschrieben oder geerbt wird, wird aufgerufen.

Ein Beispiel Abfangaufrufe dass ermöglicht die ICustomFormatter.Format-Methode und Ihnen, um festzustellen, welche Informationen die Format-Methode zu einer Formatierungsmethode für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge übergibt, finden Sie unter Beispiel 7: Ein Abfanganbieter und ein Formatierungsprogramm der römischen Zahl.

Formatelementen, die denselben Index verfügen

Die Format-Methode löst eine FormatException Ausnahme aus, wenn der Index eines Indexelements größer oder gleich der Anzahl der Argumente in der Argumentliste ist. format kann jedoch mehr Formatelementen, als sie einschließen Argumente gibt, solange mehrere Formatelemente denselben Index verfügen. Im Aufruf der Methode Format(String, Object) in folgendem Beispiel, verfügt die Argumentliste ein einzelnes Argument, die Formatzeichenfolge einschließt zwei Formatelemente: ein wird den Dezimalwert einer Nummer, und das andere wird der Hexadezimalwert an.


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


Formatieren und Kultur

Im Allgemeinen werden Objekte in der Argumentliste zu ihren Zeichenfolgendarstellungen konvertiert, indem die Konventionen der aktuellen Kultur verwendet, die durch die CultureInfo.CurrentCulture-Eigenschaft zurückgegeben wird. Sie können dieses Verhalten gesteuert, indem Sie die Format(IFormatProvider, String, Object[])-Überladung aufrufen. provider-Parameter dieser Überladung ist eine IFormatProvider Implementierung, die die benutzerdefinierte und kulturspezifische Formatierungsinformationen, die verwendet wird, um den zu Formatierungsprozess Ein.

Die IFormatProvider-Schnittstelle verfügt über einen einzelnen Member, GetFormat, der zum Zurückgeben des Objekts zuständig ist, das Formatierungsinformationen bereitstellt. . .NET Framework bietet drei IFormatProvider Implementierungen, die eine kulturabhängige Formatierung angeben:

Benutzerdefinierte Formatierungsvorgänge

Sie können die Format(IFormatProvider, String, Object[])-Überladung aufrufen, um benutzerdefinierte Formatierungsvorgänge auszuführen. Beispielsweise können Sie eine ganze Zahl als ID oder als Telefonnummer formatieren. Um benutzerdefinierte Formatierung auszuführen, muss das provider-Argument die IFormatProvider und ICustomFormatter-Schnittstellen implementieren. Wenn der Format(IFormatProvider, String, Object[])-Methode eine ICustomFormatter Implementierung als das Argument provider, die Format-Methode ruft seine IFormatProvider.GetFormat Implementierung und Anforderungen ein Objekt des Typs ICustomFormatter übergeben wird. Sie ruft dann die zurückgegebenen des ICustomFormatterFormat-Methode Objekts auf, um jedes Formatelement in der zusammengesetzten Zeichenfolge zu formatieren, die an sie übergeben wird.

Weitere Informationen über das Bereitstellen von benutzerdefinierten Formatierungsprojektmappen finden Sie unter Gewusst wie: Definieren und Verwenden von benutzerdefinierten numerischen Formatanbietern und ICustomFormatter. Ein Beispiel finden dieses Bekehrtganze zahlen zu formatierten benutzerdefinierten Zahlen, Beispiel 6: Ein benutzerdefinierter Formatierungsvorgang. Ein Beispiel hierfür finden dieses der Bytes ohne Vorzeichen in den in Zahlen, Beispiel 7: Ein Abfanganbieter und ein Formatierungsprogramm der römischen Zahl.

Beispiel 1: Stil eines einzelnen Arguments

Das folgende Beispiel bettet das Alter einer Einzelperson mithilfe der Format(String, Object)-Methode in der Mitte einer Zeichenfolge ein.


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.


Beispiel 2: Formatieren von zwei Argumenten

Dieses Beispiel verwendet die Format(String, Object, Object)-Methode zu den Anzeigedauer- und Temperaturdaten, die in einem generischen Dictionary<TKey, TValue>-Objekt gespeichert werden. Beachten Sie, dass in der Formatzeichenfolge drei Formatelemente hat, obwohl nur zwei Objekte den Stil gibt. Dies ist, da das erste Objekt in der Liste (ein Datums- und Uhrzeitwert) durch zwei Formatelemente verwendet wird: Das erste Formatelement zeigt die Zeit an, und das 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


Beispiel 3: Formatieren von drei Argumenten

Dieses Beispiel verwendet die Format(String, Object, Object, Object)-Methode, um eine Zeichenfolge zu erstellen, die das Ergebnis eines booleschen And Vorgangs mit zwei ganzzahlige Werte veranschaulicht. Beachten Sie, dass die Formatzeichenfolge sechs Formatelemente einschließt, aber die Methode verfügt nur über drei Elemente in der Parameterliste, da jedes Element auf zwei verschieden Weisen 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)


Beispiel 4: Formatieren von mehr als drei Argumenten

Dieses Beispiel erstellt eine Zeichenfolge, die Daten auf hoher und grundlegenden Temperatur auf einem bestimmten Datum enthält. Die zusammengesetzte Formatzeichenfolge hat im C#-Beispiel fünf und im Visual Basic-Beispiel sechs Formatelemente. Zwei der Formatelemente definieren die Breite der Zeichenfolgendarstellung ihres entsprechenden Werts, und das erste Formatelement schließt auch eine Standardformatzeichenfolge für Datum und Uhrzeit ein.


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 die als Array anstatt zu formatierende Objekte auch übergeben, 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


Beispiel 5: Kulturabhängige Formatierung

Dieses Beispiel verwendet die Format(IFormatProvider, String, Object[])-Methode, um die Zeichenfolgendarstellung von etwas Datums- und Uhrzeitwerte und von numerischen Werten anzuzeigen, indem mehrere verschiedene Kulturen verwendet.


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


Beispiel 6: Ein benutzerdefinierter Formatierungsvorgang

In diesem Beispiel definiert einen Formatanbieter, der einen ganzzahligen Wert als Kundenkontozahl in der Form X-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.


Beispiel 7: Ein Abfanganbieter und ein Formatierungsprogramm der römischen Zahl

In diesem Beispiel definiert einen benutzerdefinierten Formatanbieter, der die ICustomFormatter und IFormatProvider-Schnittstellen implementiert, um zwei bestimmte Aufgaben auszuführen:

  • Es zeigt die Parameter an, die ihrer Implementierung ICustomFormatter.Format übergeben werden. Dadurch können uns, um festzustellen, welche Parameter die Format(IFormatProvider, String, Object[])-Methode der benutzerdefinierte Formatierungsimplementierung für jedes Objekt übergeben, das sie versucht, zu formatieren. Dies kann nützlich sein, wenn Sie die Anwendung debuggen.

  • Wenn das zu formatierende Objekt ein Bytewert ohne Vorzeichen ist, der formatiert werden soll, indem die R-Zeile Standardformatzeichenfolge verwendet, wird das benutzerdefinierte Formatierungsprogramm den numerischen Wert als römische Zahl.


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


Versionsinformationen

.NET Framework

Alle Überladungen werden in unterstützt: 4.5, 4, 3,5, 3,0, 2,0, 1,1, 1,0

.NET Framework Client Profile

Alle Überladungen werden in unterstützt: 4, 3,5 SP1

Portable Klassenbibliotheken

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[]) werden in Windows 8 unterstützt

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft