Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina

Metoda String.Format

.NET Framework (current version)
 

Převede hodnotu objektů na řetězce podle zadané formáty a vloží je do jiného řetězce.

Pokud začínáte String.Format Metoda, naleznete v částiZačínáme s metodu String.Format oddílu pro rychlý přehled.

Viz Poznámky oddílu pro kompletní dokumentaci pro všechny String.Format přetížení.

Obor názvů:   System
Sestavení:  mscorlib (v mscorlib.dll)

NázevPopis
System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

Nahrazuje formátovací položku nebo položky v zadaného řetězce s řetězcovou reprezentací odpovídajícího objektu. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

Nahrazuje formátovací položky v zadaného řetězce s řetězcovou reprezentací dvou zadaných objektů. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

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

Nahrazuje formátovací položky v zadaného řetězce s řetězcovou reprezentací tři zadané objekty. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

Nahradí formátovací položky v zadaného řetězce řetězcové reprezentace odpovídající objekty v určeném poli. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

Nahradí jednu nebo více položek formátu v zadaného řetězce s řetězcovou reprezentací zadaného objektu.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

Nahrazuje formátovací položky v zadaného řetězce s řetězcovou reprezentací dvou zadaných objektů.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

Nahrazuje formátovací položky v zadaného řetězce s řetězcovou reprezentací tři zadané objekty.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object[])

Nahrazuje formátovací položku v zadaného řetězce s řetězcovou reprezentací odpovídajícího objektu v určeném poli.

Použití String.Format Pokud je třeba vložit hodnotu objektu, proměnné nebo výrazu do jiného řetězce. Například můžete vložit hodnotu Decimal hodnotu do řetězce, můžete ho zobrazit uživateli jako jeden řetězec:

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.

A můžete řídit formátování tuto hodnotu:

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.

Kromě formátování, můžete také ovládat zarovnání a mezery.

Vkládání řetězec

String.Format začíná řetězec formátu, za nímž následuje jeden nebo více objektů nebo výrazy, které budou převedeny na řetězce a vložit na určeném místě ve formátovacím řetězci. Příklad:

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

{0} Ve formátu řetězce je položka formátu. 0 je index objektu, jejichž řetězcová hodnota bude převeden na této pozici. (Indexy začínají hodnotou 0.) Pokud objekt, který má být vložen není řetězec, jeho ToString Metoda je volána pro převod na jednu před vložením ve výsledném řetězci.

Zde je další příklad, který používá dvě položky formátu a dva objekty v seznamu objektů:

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

Může mít libovolný počet položek formátu a libovolný počet objektů v seznamu objektů, jako je třeba, tak dlouho, dokud index každá položka formátu má odpovídající objekt v seznamu objektů. Také nemusíte si dělat starosti o které přetížení zavoláte; Kompilátor bude vyberte příslušný pro vás.

Řízení, formátování

Můžete řídit indexu v položce formátu pomocí formátovacího řetězce k řízení formátování objektu. Například {0:d} řetězec formátu "d" se vztahuje na první objekt v seznamu objektů. Zde je příklad s jeden objekt a dvě položky formátu:

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'

Počet typů podpora formátu řetězce, včetně všechny číselné typy (obě Standardní a Vlastní řetězce formátu), všechna data a časy (obě Standardní a Vlastní řetězce formátu) a časové intervaly (obě Standardní a Vlastní řetězce formátu), všechny typy výčtu výčtové typy, a GUIDs. Můžete také přidat podporu pro formátovací řetězce na vlastní typy.

Řízení mezery

Můžete definovat šířka řetězec, který je vložen do výsledného řetězce pomocí syntaxe {0,12}, která vloží řetězec znaků 12. V tomto případě řetězcové vyjádření první objekt je zarovnána doprava v poli 12 znaků. (Pokud řetězcové vyjádření první objekt je více než 12 znaků, ale šířku pole upřednostňovaného ignorována a celý řetězec je vložen do výsledného řetězce.)

Následující příklad definuje pole 6 znaků pro uložení řetězec "Rok" a některé řetězce rok, jakož i o 15 znaků pole pro uložení řetězec "Plnění" a některá data základního souboru. Všimněte si, že znaky jsou zarovnána doprava v poli.

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
Řízení zarovnání

Ve výchozím nastavení jsou řetězce zarovnána doprava, v rámci jejich pole je-li určit šířku pole. Zarovnat řetězců v poli vlevo, před šířka pole se záporným znaménkem, jako je například {0,-12} k definici pole vpravo zarovnaný 12 znaků.

Následující příklad je podobný předchozímu, s výjimkou, že ji vlevo – zarovná popisky a data.

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.Format využívá funkce složeného formátování. Další informace naleznete v tématu Složené formátování.

Další informace týkající se přetížení naleznete v tématu jakou metodu můžu volat?

String String.Format(String format, Object arg0)

Nahrazuje formátovací položky s řetězcovou reprezentací zadaný objekt (Příklad).

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

Nahrazuje formátovací položky s řetězcovou reprezentací dvou zadaných objektů (Příklad).

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

Nahrazuje formátovací položky s řetězcovou reprezentací tři zadané objekty (Příklad).

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

Nahrazuje formátovací položky s řetězcové reprezentace odpovídající objekty v určeném poli (Příklad).

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

Nahrazuje formátovací položky s řetězcovou reprezentací odpovídajícího objektů v určeném poli a používá zadané informace o formátování specifické pro jazykovou verzi (Příklad) nebo vlastní informace o formátování (Příklad).

Toto je úplný seznam parametrů pro Format Metoda; viz syntaxe přetížení výše pro parametry, které používají jednotlivá přetížení. Pouze format parametr je používán všechna přetížení.

Parametr

Typ

Popis

format

String

Složený formátovací řetězec, který obsahuje jeden nebo více položek formátu (viz položka formátu).

arg0

String

První nebo pouze objekt pro formátování.

arg1

String

Druhý objekt pro formátování.

arg2

String

Třetí objekt pro formátování.

args

String[]

Nula nebo více objektů, které chcete formátovat, zadaný v čárkami oddělený seznam nebo jako pole.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi nebo vlastní.

Typ: String
kopii format v kterém položky formátu byly nahrazeny řetězcové reprezentace odpovídající argumenty.

Výjimka

Podmínka

Vyvolané

ArgumentNullException

format je null.

Všechna přetížení.

FormatException

format je neplatný.

- nebo -

Index položky formátu je menší než nula, nebo větší než nebo roven počtu argumentů v seznamu argumentů.

Všechna přetížení.

K

Volání

Formátovat jeden nebo více objektů pomocí konvencí aktuální jazykové verze.

S výjimkou přetížení, které obsahují provider parametr zbývajícíFormat přetížení zahrnout String parametr následuje jeden nebo více parametrů objektu. Z tohoto důvodu není nutné zjistit, který Format přetížení, které máte v úmyslu volání. Váš kompilátor jazyka vybere příslušného přetížení z přetížených metod, které nemají provider parametr založených na seznamu argumentů. Například pokud váš argument seznam má pět argumentů, kompilátor bude volat Format(String, Object[]) Metoda.

Jeden nebo více objektů formátu pomocí konvencí konkrétní jazykové verze.

KaždýFormatpřetížení, která začíná provider parametr následuje String parametr a jeden nebo více objektů parametry. Z tohoto důvodu není nutné určit, jaké zvláštní Format přetížení, které máte v úmyslu volání. Váš kompilátor jazyka vybere příslušného přetížení z přetížených metod, které mají provider parametr založených na seznamu argumentů. Například pokud váš argument seznam má pět argumentů, kompilátor bude volat Format(IFormatProvider, String, Object[]) Metoda.

Vlastní operace formátování provést buď pomocí ICustomFormatter implementace nebo IFormattable implementace.

Všechny čtyři přetížení s provider parametr. Kompilátor bude vyberte příslušného přetížení z přetížených metod, které mají provider parametr založených na seznamu argumentů.

Každé přetížení Format Metoda používá funkce složeného formátování zahrnout od nuly indexovaných zástupných textů označovaných jako položky formátu v složený řetězec formátu. V době běhu každá položka formátu je nahrazena řetězcovou reprezentací odpovídajícího argumentu v seznamu parametrů. Pokud je hodnota argumentu null, položka formátu je nahrazena String.Empty. Například následující volání Format(String, Object, Object, Object) Metoda obsahuje řetězec formátu s položkami tři formátu, {0}, {1} a {2} a seznam argumentů s tří položek.

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.   

Položka formátu má tuto syntaxi:


{
index[,alignment][ :formatString] }

Závorky označují volitelné prvky. Otevírací a uzavírací závorky jsou vyžadovány. (Zahrnout literální znak levé nebo pravé složené závorky v řetězci formátu naleznete v části "Uvozovací znaky složených závorek" v Složené formátování článku.)

Položka formátu do formátu, který může být hodnota měny se zobrazí takto:

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

Položka formátu má následující prvky:

index

Z nuly vycházející index argument, jehož řetězcové vyjádření má být zahrnut v této pozici v řetězci. Pokud je tento argument null, prázdný řetězec budou zahrnuty v této pozici v řetězci.

zarovnání

Volitelný parametr. Znaménkem, které udává celkovou délku pole, do kterého je vložen argument a zda jsou zarovnána doprava (kladné celé číslo) nebo doleva (záporné celé číslo). Vynecháte-li zarovnání, řetězcovou reprezentací odpovídajícího argumentu je vložena do pole bez počátečních a koncových mezer.

Pokud hodnota zarovnání je menší než délka argumentu, který má být vložen, zarovnání je ignorován a délka řetězcové vyjádření argument slouží jako šířka pole.

formatString

Volitelný parametr. Řetězec, který určuje formát výsledného řetězce odpovídající argument. Vynecháte-li formatString, že odpovídající argument uživatele bez parametrů ToString Metoda je volána k vytvoření řetězcové vyjádření. Pokud zadáte formatString, musí implementovat argument odkazuje položka formátu IFormattable rozhraní. Typy, které podporují řetězce formátu patří:

Uvědomte si však, že každý vlastní typ můžete implementovat IFormattable nebo rozšířit existující typ IFormattable implementace.

Následující příklad používá alignment a formatString argumenty k vytvoření formátovaný výstup.

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 %

Položky formátu jsou zpracovávány postupně od začátku řetězce. Každá položka formátu má index, který odpovídá objektu v seznamu argumentů metody. Format Metoda načte argument a je odvozena řetězcové vyjádření následujícím způsobem:

Příklad, který zachycuje volání ICustomFormatter.Format Metoda a umožňuje zjistit, které informace Format Metoda předá metoda formátování pro každou položku formátu v složený řetězec formátu, naleznete v části příklad 7: poskytovatel zachycení a formátovací modul římských číslic.

Format Vyvolá metoda výjimku FormatException výjimka, pokud je index položky index je větší než nebo rovna hodnotě počet argumentů v seznamu argumentů. Však format může obsahovat více položek formátu, než jsou argumenty, tak dlouho, dokud více položek formátu mají stejný index. Ve volání Format(String, Object) metodu v následujícím příkladu seznamu argumentů má jeden argument, ale řetězec formátu zahrnuje dvě položky formátu: jeden zobrazí desítkové hodnoty čísla, a druhé její šestnáctkové hodnoty.

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

Obecně platí, objekty v seznamu argumentů jsou převedeny na jejich řetězcové vyjádření pomocí konvencí aktuální jazykové verze, která je vrácena CultureInfo.CurrentCulture vlastnost. Toto chování můžete řídit pomocí jednoho z přetížení volání Format který obsahuje provider parametr. provider Parametr je IFormatProvider implementace, která poskytuje specifické pro jazykovou verzi a vlastní informace o formátování použitého k střední formátování zpracovat.

IFormatProvider Rozhraní má jeden člen, GetFormat, která je odpovědná za vrácení objektu, který poskytuje informace o formátování. Rozhraní .NET Framework má tři IFormatProvider implementace, které poskytují formátování specifické pro jazykovou verzi:

  • CultureInfo. Jeho GetFormat Metoda vrátí specifické jazykové verze NumberFormatInfo objekt pro formátování číselných hodnot a specifické jazykové verze DateTimeFormatInfo objekt pro formátování hodnot data a času.

  • DateTimeFormatInfo, který se používá pro specifické pro jazykovou verzi formátování hodnot data a času. Jeho GetFormat metoda vrací samu sebe.

  • NumberFormatInfo, který se používá pro specifické pro jazykovou verzi formátování číselných hodnot. Jeho GetFormat vlastnost vrací samu sebe.

Můžete také volat některý z přetížení Format metodu, která mají provider parametr Format(IFormatProvider, String, Object[]) přetížení provádět vlastní operace formátování. Například můžete naformátovat celé číslo jako identifikační číslo nebo telefonní číslo. K provedení vlastní formátování vaše provider argument musí implementovat obě IFormatProvider a ICustomFormatter rozhraní. PřiFormat metodě je předána ICustomFormatter implementace jako provider argument, Format volání metody jeho IFormatProvider.GetFormat implementace a požaduje objekt typu ICustomFormatter. Poté zavolá vrácený ICustomFormatter objektu Format předán metodě každou formátovací položku v složený řetězec formátu.

Další informace o poskytování vlastní formátování řešení, naleznete v části Postupy: Definování a používání vlastních poskytovatelů číselného formátu a ICustomFormatter. Příklad, který převede celých čísel na formátovaný vlastní čísla, naleznete v části příklad 6: vlastní operace formátování. Příklad, který převede bajtů bez znaménka na římské číslice, naleznete v části příklad 7: poskytovatel zachycení a formátovací modul římských číslic.

Následující příklad používá Format(String, Object) Metoda pro vložení jednotlivého uživatele stáří uprostřed řetězec.

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.

V tomto příkladu Format(String, Object, Object) Metoda zobrazíte času a teploty data uložená v generických Dictionary<TKey, TValue> objektu. Upozorňujeme, že řetězec formátu má tři položky formátu, i když existují pouze dva objekty, které chcete formátovat. Důvodem je, že první objekt v seznamu (hodnota data a času) se používá dvě položky formátu: první zobrazí položky formátu času a druhý zobrazí datum.

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

V tomto příkladu Format(String, Object, Object, Object) Metoda pro vytvoření řetězce, který znázorňuje výsledek logickou hodnotu And operaci s dvou celočíselných hodnot. Poznámka: řetězec formátu obsahuje šest položek formátu, že tato metoda má pouze tři položky jejího seznamu parametrů, protože každá položka je formátováno dvěma různými způsoby.

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)

Tento příklad vytvoří řetězec, který obsahuje data na vysoké a nízké teploty v určitý den. Složený formátovací řetězec má pět položek formátu v příkladu C# a šest v příkladu Visual Basic. Dvě položky formátu definovat šířka jejich odpovídající hodnoty řetězcové vyjádření a první položka formátu také obsahuje standardní hodnoty data a času formátovací řetězec.

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)

Můžete také předat objekty, které chcete formátovat jako pole spíše než seznam argumentů.

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

V tomto příkladu Format(IFormatProvider, String, Object[]) Metoda zobrazit řetězcové vyjádření některé hodnoty data a času a číselných hodnot pomocí několika různými jazykovými verzemi.

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

Tento příklad definuje poskytovatele formátu, který zformátuje celočíselnou hodnotu jako číslo účtu odběratele ve formuláři x-xxxxx-xx.

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.

Tento příklad definuje zprostředkovatele vlastního formátu, který implementuje ICustomFormatter a IFormatProvider rozhraní provést dva kroky:

  • Zobrazí parametry předávané jeho ICustomFormatter.Format implementace. To umožňuje nám zobrazíte jaké parametry Format(IFormatProvider, String, Object[]) metoda předává na vlastní formátování implementaci pro každý objekt, který se pokusí pro formátování. To může být užitečné při ladění aplikace.

  • Pokud objekt, který má být formátováno je hodnota bez znaménka bajtů, které má být naformátován pomocí řetězce standardního formátu "R", vlastní formátovací modul formátuje číselnou hodnotu jako římských číslic.

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

Podporou všech přetížení: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

Profil klienta rozhraní .NET Framework

Podporou všech přetížení: 4, 3.5 SP1

Přenosná knihovna tříd

Pouze Format(String, Object[]) a Format(IFormatProvider, String, Object[]) jsou podporovány

Aplikace .NET pro Windows Store

Pouze Format(String, Object[]) a Format(IFormatProvider, String, Object[]) jsou podporovány v systému Windows 8

Toto je Obecná syntaxe položky formátu:

{index[,alignment][: formatString]}

kde zarovnání se znaménkem, které definuje šířku pole. Pokud je tato hodnota záporná, je text v poli zarovnána doleva. Je-li kladné, text je zarovnán doprava.

Všechny řetězce standardního číselného formátu kromě "D" (který se používá s pouze celá čísla), "G", "R" a "X" Povolit specifikátor přesnosti, která definuje počet desetinných míst ve výsledném řetězci. Následující příklad používá řetězce standardního číselného formátu k řízení počet desetinných míst ve výsledném řetězci.

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 %

Pokud používáte vlastní číselný formátovací řetězec, k ovládání počet desetinných míst ve výsledném řetězci, jak ukazuje následující příklad používá specifikátor formátu "0".

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

Ve výchozím nastavení zobrazí operací formátování pouze integrální číslice nula. Při formátování celých čísel, můžete použít specifikátor přesnosti s "D" a "X" standardní řetězce formátu pro řízení počet číslic.

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

Je možné doplnit celé číslo nebo číslo s plovoucí desetinnou čárkou s nulami vytvoření výsledný řetězec s zadaný počet integrálních číslic pomocí "0" Specifikátor vlastního číselného formátu, jak ukazuje následující příklad.

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

Neexistuje žádné praktické omezení. Druhý parametr Format(IFormatProvider, String, Object[]) Metoda je označena jako ParamArrayAttribute atribut, který umožňuje zahrnout oddělený seznam nebo pole objektu jako seznam formátu.

Příklad, jak můžete zabránit následující volání metody z vyvolávání FormatException výjimka?

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

Jeden otevírací nebo uzavírací složenou závorku je vždy interpretovány jako začátek nebo konec položky formátu. Chcete-li být interpretován doslovně, musí být uvozena. Řídicí složená závorka přidáním jiného složenou závorku ("{{" a "}}" místo "{" a "}"), jako v následujícím volání metody:

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

Nicméně jsou snadno misinterpreted i řídicími znaky složených závorek. Doporučujeme, abyste obsahují složené závorky v seznamu formát a vložit je do výsledného řetězce, jak ukazuje následující příklad pomocí položky formátu.

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

Nejběžnější příčina výjimky je, že index položky formátu neodpovídá objektu v seznamu formát. Obvykle to znamená, že jste misnumbered indexy položky formátu nebo jste zapomněli zahrnují objekt v seznamu formát. V některých případech výjimky je výsledkem překlep; Například typický chybou je chybně "[" (levou závorku) namísto "{" (levou složenou závorku).

Například následující kód vyvolá výjimku FormatException Výjimka:

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);   
   }
}

Toto je problém kompilátoru řešení přetížení. Protože kompilátor nemůže převést pole celých čísel na pole objektu, jeho celočíselné pole zpracovává jako jeden argument, tak volá Format(String, Object) Metoda. Výjimka je vyvolána, protože existují čtyři položky formátu, ale pouze jednu položku v seznamu formát.

Protože Visual Basic ani C# lze převést celočíselné pole pole objektu, je třeba provést převod před zavoláním Format(String, Object[]) Metoda. Následující příklad poskytuje jednu implementaci.

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);   
   }
}
Zpět na začátek
Zobrazit: