Metoda System.String.Format
Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.
Důležité
Místo volání metody String.Format nebo použití složených formátových řetězců můžete použít interpolované řetězce , pokud je jazyk podporuje. Interpolovaný řetězec je řetězec, který obsahuje interpolované výrazy. Každý interpolovaný výraz se přeloží na hodnotu výrazu a zahrne se do výsledného řetězce při přiřazení řetězce. Další informace naleznete v tématu Interpolace řetězců (Referenční dokumentace jazyka C#) a Interpolované řetězce (Referenční dokumentace jazyka Visual Basic).
Příklady
Mnoho příkladů, které volají metodu Format , jsou interspersed v tomto článku. Můžete si také stáhnout kompletní sadu String.Format příkladů, které jsou součástí projektu .NET Core pro C#.
Tady jsou některé příklady, které jsou součástí článku:
Vytvoření řetězce formátu
Vložení řetězce
Položka formátu
Formátování položek se stejným indexem
Řízení formátovaného výstupu
Formátování ovládacího prvku
Mezery ovládacích prvků
Zarovnání ovládacího prvku
Řízení počtu integrálních číslic
Určuje počet číslic za oddělovačem desetinných míst.
Zahrnutí složených závorek do výsledného řetězce
Nastavení jazykových verzí pro formátovací řetězce
Nastavení jazykových verzí pro formátovací řetězce
Přizpůsobení operace formátování
Operace vlastního formátování
Zprostředkovatel průsečíku a římská číslice
Začínáme s metodou String.Format
Použijte String.Format , pokud potřebujete vložit hodnotu objektu, proměnné nebo výrazu do jiného řetězce. Můžete například vložit hodnotu hodnoty Decimal do řetězce a zobrazit ji uživateli jako jeden řetězec:
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%s"
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0} per ounce.",
pricePerOunce)
' Result: The current price is 17.36 per ounce.
A formátování této hodnoty můžete řídit takto:
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%s"
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce)
' Result if current culture is en-US:
' The current price is $17.36 per ounce.
Kromě formátování můžete také řídit zarovnání a mezery.
Vložení řetězce
String.Format začíná formátovacím řetězcem následovaným jedním nebo více objekty nebo výrazy, které budou převedeny na řetězce a vloženy na zadané místo v řetězci formátu. 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.'
let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%s"
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4D
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'
V {0} řetězci formátu je položka formátu. 0 je index objektu, jehož řetězcová hodnota bude vložena do této pozice. (Indexy začínají na 0.) Pokud objekt, který chcete vložit, není řetězec, jeho ToString metoda je volána k převodu na jeden před vložením do výsledného řetězce.
Tady 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);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%s"
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
V seznamu objektů můžete mít tolik položek formátu a libovolný počet objektů, pokud má index každé položky formátu odpovídající objekt v seznamu objektů. Také se nemusíte starat o přetížení, které voláte; kompilátor vybere ten, který je pro vás vhodný.
Formátování ovládacího prvku
Můžete postupovat podle indexu v položce formátu s řetězcem formátu a řídit, jak je objekt formátován. Například {0:d} použije řetězec formátu "d" na první objekt v seznamu objektů. Tady je příklad s jedním objektem a dvěma položkami formátu:
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%s"
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Řada typů podporuje formátovací řetězce včetně všech číselných typů (standardních i vlastních formátových řetězců), všech kalendářních dat a časů (standardních i vlastních formátových řetězců) a časových intervalů (standardní i vlastní formátovací řetězce), všech typů výčtů a identifikátorů GUID. Do vlastních typů můžete také přidat podporu formátových řetězců.
Mezery ovládacích prvků
Šířku řetězce, který je vložen do výsledného řetězce, můžete definovat pomocí syntaxe, například {0,12}, která vloží řetězec s 12 znaky. V tomto případě je řetězcová reprezentace prvního objektu zarovnaná doprava v poli s 12 znaky. (Pokud je řetězcová reprezentace prvního objektu delší než 12 znaků, je však upřednostňovaná šířka pole ignorována a celý řetězec se vloží do výsledného řetězce.)
Následující příklad definuje 6mísícové pole, které bude obsahovat řetězec Year a některé řetězce roku, stejně jako pole s 15 znaky pro uložení řetězce "Population" a některých dat základního souboru. Všimněte si, že znaky jsou v poli zarovnané doprava.
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));
Console.WriteLine(sb);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
open System
open System.Text
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore
printfn $"{sb}"
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
"Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
sb.AppendFormat("{0,6} {1,15:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
Zarovnání ovládacího prvku
Ve výchozím nastavení jsou řetězce v poli zarovnané doprava, pokud zadáte šířku pole. Pokud chcete v poli zarovnat řetězce doleva, předepíšete šířku pole záporným znaménkem, například {0,-12} definovat 12mísícové pole zarovnané doleva.
Následující příklad je podobný předchozímu, s tím rozdílem, že zarovná popisky i data doleva.
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for (int index = 0; index < years.Length; index++)
s += String.Format("{0,-10} {1,-10:N0}\n",
years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\n{s}"
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
"Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
s += String.Format("{0,-10} {1,-10:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
String.Format využívá funkci složeného formátování. Další informace naleznete v tématu Složené formátování.
Jakou metodu mám volat?
| Záměr | Call |
|---|---|
| Naformátujte 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í zahrnují String parametr následovaný jedním nebo více parametry objektu. Z tohoto důvodu nemusíte určit, které Format přetížení chcete volat. Kompilátor jazyka vybere odpovídající přetížení z přetížení, která nemají provider parametr na základě seznamu argumentů. Pokud má například seznam argumentů pět argumentů, kompilátor volá metodu Format(String, Object[]) . |
| Naformátujte jeden nebo více objektů pomocí konvencí konkrétní jazykové verze. | Za každým Format přetížením, které začíná parametrem provider , následuje String parametr a jeden nebo více parametrů objektu. Z tohoto důvodu nemusíte určit, které konkrétní Format přetížení chcete volat. Kompilátor jazyka vybere příslušné přetížení z přetížení, která mají provider parametr na základě seznamu argumentů. Pokud má například seznam argumentů pět argumentů, kompilátor volá metodu Format(IFormatProvider, String, Object[]) . |
| Proveďte vlastní operaci formátování buď s ICustomFormatter implementací, nebo implementací IFormattable . | Jakékoli ze čtyř přetížení s parametrem provider . Kompilátor vybere příslušné přetížení z přetížení, která mají provider parametr na základě seznamu argumentů. |
Přehled metody Format
Každé přetížení Format metody používá funkci složeného formátování k zahrnutí indexovaných zástupných symbolů založených na nule, označovaných jako formátovat položky, do řetězce složeného formátu. Za běhu se každá položka formátu nahradí řetězcovou reprezentací odpovídajícího argumentu v seznamu parametrů. Pokud je nullhodnota argumentu , položka formátu je nahrazena String.Empty. Například následující volání Format(String, Object, Object, Object) metody obsahuje formátovací řetězec se třemi položkami formátu, {0}, {1}a {2}a seznam argumentů se třemi položkami.
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0);
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
open System
let dat = DateTime(2012, 1, 17, 9, 30, 0)
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// The example displays output like the following:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Dim dat As Date = #1/17/2012 9:30AM#
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
' At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Položka formátu
Položka formátu má tuto syntaxi:
{index[,alignment][:formatString]}
Závorky označují volitelné prvky. Jsou vyžadovány levá a pravá složená závorka. (Pokud chcete do řetězce formátu zahrnout literálovou levou nebo pravou složenou závorku, podívejte se na Oddíl složených závorek v článku o složeného formátování .)
Například položka formátu pro formátování hodnoty měny může vypadat takto:
var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);
open System
String.Format("{0,-10:C}", 126347.89m)
|> printfn "%s"
String.Format("{0,-10:C}", 126347.89D)
Položka formátu má následující prvky:
Index
Index založený na nule argumentu, jehož řetězcové vyjádření má být zahrnuto na této pozici v řetězci. Pokud je nulltento argument , prázdný řetězec bude zahrnut na této pozici v řetězci.
Zarovnání
Nepovinné. Celé číslo se znaménkem, které označuje celkovou délku pole, do kterého je argument vložen a zda je zarovnaná doprava (kladné celé číslo) nebo zarovnané doleva (záporné celé číslo). Pokud vynecháte zarovnání, vloží se řetězcová reprezentace odpovídajícího argumentu do pole bez počátečních nebo koncových mezer.
Pokud je hodnota zarovnání menší než délka argumentu, který se má vložit, zarovnání se ignoruje a délka řetězcového vyjádření argumentu se použije jako šířka pole.
Formatstring
Nepovinné. Řetězec, který určuje formát výsledného řetězce odpovídajícího argumentu. Pokud vynecháte formatString, je volána odpovídající metoda bez parametrů ToString argumentu k vytvoření řetězcové reprezentace. Pokud zadáte formatString, argument odkazovaný položkou formátu musí implementovat IFormattable rozhraní. Mezi typy podporující formátovací řetězce patří:
Všechny celočíselné typy a typy s plovoucí desetinou čárkou. (Viz Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.)
DateTime a DateTimeOffset. (Viz Standardní řetězce formátu data a času a vlastní řetězce formátu data a času.)
Všechny typy výčtů. (Viz Výčtové řetězce formátu.)
TimeSpan Hodnoty. (Viz Standardní řetězce formátu TimeSpan a vlastní řetězce formátu TimeSpan.)
Guid. (Viz Guid.ToString(String) metoda.)
Mějte však na paměti, že jakýkoli vlastní typ může implementovat IFormattable nebo rozšířit implementaci existujícího IFormattable typu.
Následující příklad používá k vytvoření formátovaného výstupu alignment argumenty a formatString argumenty.
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities =
{ Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277,
new DateTime(1950, 1, 1), 1970358),
Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995,
new DateTime(1950, 1, 1), 7891957),
Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808,
new DateTime(1950, 1, 1), 3620962),
Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452,
new DateTime(1950, 1, 1), 1849568) };
// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
"City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3)/ (double)city.Item3);
Console.WriteLine(output);
}
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities =
[ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
"New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
"Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
"Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]
// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"
for name, year1, pop1, year2, pop2 in cities do
String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
name, year1, pop1, year2, pop2,
double (pop2 - pop1) / double pop1)
|> printfn "%s"
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
Module Example3
Public Sub Main()
' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Dim cities() =
{Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),
Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),
Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568)}
' Display header
Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
"City", "Year", "Population", "Change (%)")
Console.WriteLine(header)
Console.WriteLine()
For Each city In cities
Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3) / city.Item3)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' City Year Population Year Population Change (%)
'
' Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
' New York 1940 7,454,995 1950 7,891,957 5.9 %
' Chicago 1940 3,396,808 1950 3,620,962 6.6 %
' Detroit 1940 1,623,452 1950 1,849,568 13.9 %
Formátování argumentů
Položky formátu se zpracovávají postupně od začátku řetězce. Každá položka formátu má index, který odpovídá objektu v seznamu argumentů metody. Metoda Format načte argument a odvodí jeho řetězcové vyjádření následujícím způsobem:
Pokud je
nullargument , metoda vloží String.Empty do výsledného řetězce. Nemusíte se zabývat zpracováním NullReferenceException argumentů s hodnotou null.Pokud zavoláte Format(IFormatProvider, String, Object[]) přetížení a implementace objektu
providerIFormatProvider.GetFormat vrátí nenulovou ICustomFormatter implementaci, argument se předá jeho ICustomFormatter.Format(String, Object, IFormatProvider) metodě. Pokud položka formátu obsahuje argument formatString , je předán jako první argument metodě. ICustomFormatter Pokud je implementace k dispozici a vytvoří řetězec, který není null, tento řetězec se vrátí jako řetězcové vyjádření argumentu. V opačném případě se provede další krok.Pokud argument implementuje IFormattable rozhraní, jeho IFormattable.ToString implementace je volána.
Volá se metoda bez
ToStringparametrů, která buď přepíše nebo dědí z implementace základní třídy.
Příklad, který zachycuje volání ICustomFormatter.Format metody a umožňuje zjistit, jaké informace Format metoda předává metodě formátování pro každou položku formátu ve složeného formátu řetězec, viz Příklad: Zprostředkovatel průsečíku a římské číslice formatter.
Další informace naleznete v tématu Zpracování objednávky.
Položky formátu, které mají stejný index
Metoda Format vyvolá FormatException výjimku, pokud je index položky indexu větší nebo roven počtu argumentů v seznamu argumentů. Může však obsahovat více položek formátu, format než jsou argumenty, pokud má více položek formátu stejný index. Ve volání Format(String, Object) metody v následujícím příkladu má seznam argumentů jeden argument, ale formátovací řetězec obsahuje dvě položky formátu: jedna zobrazuje desetinnou hodnotu čísla a druhá zobrazuje jeho šestnáctkovou hodnotu.
short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10} {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
string formatString = String.Format("{0,10:G}: {0,10:X}", value);
Console.WriteLine(formatString);
}
// The example displays the following output:
// Decimal Hex
//
// -32768: 8000
// -27: FFE5
// 0: 0
// 1042: 412
// 32767: 7FFF
open System
let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s %10s\n" "Decimal" "Hex"
for value in values do
String.Format("{0,10:G}: {0,10:X}", value)
|> printfn "%s"
// The example displays the following output:
// Decimal Hex
//
// -32768: 8000
// -27: FFE5
// 0: 0
// 1042: 412
// 32767: 7FFF
Module Example1
Public Sub Main()
Dim values() As Short = {Int16.MinValue, -27, 0, 1042, Int16.MaxValue}
Console.WriteLine("{0,10} {1,10}", "Decimal", "Hex")
Console.WriteLine()
For Each value As Short In values
Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
Console.WriteLine(formatString)
Next
End Sub
End Module
' The example displays the following output:
' Decimal Hex
'
' -32768: 8000
' -27: FFE5
' 0: 0
' 1042: 412
' 32767: 7FFF
Formátování a jazyková verze
Obecně platí, že objekty v seznamu argumentů jsou převedeny na jejich řetězcové reprezentace pomocí konvencí aktuální jazykové verze, která je vrácena CultureInfo.CurrentCulture vlastností. Toto chování můžete řídit voláním jednoho z přetížení Format , které zahrnuje provider parametr. Parametr provider je IFormatProvider implementace, která poskytuje informace o formátování specifické pro vlastní jazykovou verzi, které slouží k moderování procesu formátování.
Rozhraní IFormatProvider má jeden člen , GetFormatkterý je zodpovědný za vrácení objektu, který poskytuje informace o formátování. .NET má tři IFormatProvider implementace, které poskytují formátování specifické pro jazykovou verzi:
- CultureInfo. Jeho GetFormat metoda vrátí objekt specifický pro NumberFormatInfo jazykovou verzi pro formátování číselných hodnot a objekt specifický pro DateTimeFormatInfo jazykovou verzi pro formátování hodnot data a času.
- DateTimeFormatInfo, který se používá pro formátování hodnot data a času specifické pro jazykovou verzi. Její GetFormat metoda se vrátí sama.
- NumberFormatInfo, který se používá pro formátování číselné hodnoty specifické pro jazykovou verzi. Její GetFormat(Type) metoda se vrátí sama.
Vlastní operace formátování
Můžete také volat jakékoli přetížení Format metody, které mají provider parametr typu IFormatProvider provádět vlastní operace formátování. Můžete například naformátovat celé číslo jako identifikační číslo nebo jako telefonní číslo. Pokud chcete provést vlastní formátování, musí argument provider implementovat rozhraní IFormatProvider i ICustomFormatter rozhraní. Format Pokud metoda je předána ICustomFormatter implementace jako provider argument, Format metoda volá jeho IFormatProvider.GetFormat implementaci a požaduje objekt typu ICustomFormatter. Potom volá vrácenou metodu objektu ICustomFormatterFormat k naformátování každé položky formátu ve složeného řetězci předaného do něj.
Další informace o poskytování vlastních řešení formátování naleznete v tématu Postupy: Definování a použití vlastních zprostředkovatelů číselného formátu a ICustomFormatter. Příklad, který převede celá čísla na formátovaná vlastní čísla, viz Příklad: Vlastní operace formátování. Příklad, který převede nepodepsané bajty na římské číslice, viz Příklad: Zprostředkovatel průsečíku a římské číslice formatter.
Příklad: Vlastní operace formátování
Tento příklad definuje zprostředkovatele formátu, který formátuje celočíselnou hodnotu jako číslo účtu zákazníka ve formátu 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.
open System
type CustomerFormatter() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member this.Format(format, arg, formatProvider: IFormatProvider) =
if this.Equals formatProvider |> not then
null
else
let format =
if String.IsNullOrEmpty format then "G"
else format.ToUpper()
let customerString =
let s = string arg
if s.Length < 8 then
s.PadLeft(8, '0')
else s
match format with
| "G" ->
customerString.Substring(0, 1) + "-" +
customerString.Substring(1, 5) + "-" +
customerString.Substring 6
| "S" ->
customerString.Substring(0, 1) + "/" +
customerString.Substring(1, 5) + "/" +
customerString.Substring 6
| "P" ->
customerString.Substring(0, 1) + "." +
customerString.Substring(1, 5) + "." +
customerString.Substring 6
| _ ->
raise (FormatException $"The '{format}' format specifier is not supported.")
let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
String.Format(CustomerFormatter(), "{0:X}", acctNumber)
|> printfn "%s"
with :? FormatException as e ->
printfn $"{e.Message}"
// The example displays the following output:
// 7-92031-59
// 7-92031-59
// 7/92031/59
// 7.92031.59
// The 'X' format specifier is not supported.
Module TestFormatter
Public Sub Main()
Dim acctNumber As Integer = 79203159
Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
Try
Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
Catch e As FormatException
Console.WriteLine(e.Message)
End Try
End Sub
End Module
Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(type As Type) As Object _
Implements IFormatProvider.GetFormat
If type Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, _
arg As Object, _
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
If Not Me.Equals(formatProvider) Then
Return Nothing
Else
If String.IsNullOrEmpty(fmt) Then fmt = "G"
Dim customerString As String = arg.ToString()
if customerString.Length < 8 Then _
customerString = customerString.PadLeft(8, "0"c)
Select Case fmt
Case "G"
Return customerString.Substring(0, 1) & "-" & _
customerString.Substring(1, 5) & "-" & _
customerString.Substring(6)
Case "S"
Return customerString.Substring(0, 1) & "/" & _
customerString.Substring(1, 5) & "/" & _
customerString.Substring(6)
Case "P"
Return customerString.Substring(0, 1) & "." & _
customerString.Substring(1, 5) & "." & _
customerString.Substring(6)
Case Else
Throw New FormatException( _
String.Format("The '{0}' format specifier is not supported.", fmt))
End Select
End If
End Function
End Class
' The example displays the following output:
' 7-92031-59
' 7-92031-59
' 7/92031/59
' 7.92031.59
' The 'X' format specifier is not supported.
Příklad: Zprostředkovatel průsečíku a římská číslice
Tento příklad definuje vlastního zprostředkovatele formátu, který implementuje ICustomFormatter rozhraní a IFormatProvider provádí dvě věci:
Zobrazí parametry předané jeho ICustomFormatter.Format implementaci. To nám umožňuje zjistit, jaké parametry Format(IFormatProvider, String, Object[]) metoda předává implementaci vlastního formátování pro každý objekt, který se pokouší formátovat. To může být užitečné při ladění aplikace.
Pokud objekt, který má být formátován, je nepodepsaná bajtová hodnota, která má být formátována pomocí standardního formátovacího řetězce "R", vlastní formátovací modul formátuje číselnou hodnotu jako římské číslice.
using System;
using System.Globalization;
public class InterceptProvider : IFormatProvider, ICustomFormatter
{
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(String format, Object obj, IFormatProvider provider)
{
// Display information about method call.
string formatString = format ?? "<null>";
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider.GetType().Name, obj ?? "<null>", formatString);
if (obj == null) return String.Empty;
// If this is a byte and the "R" format string, format it with Roman numerals.
if (obj is Byte && formatString.ToUpper().Equals("R")) {
Byte value = (Byte) obj;
int remainder;
int result;
String returnString = String.Empty;
// Get the hundreds digit(s)
result = Math.DivRem(value, 100, out remainder);
if (result > 0)
returnString = new String('C', result);
value = (Byte) remainder;
// Get the 50s digit
result = Math.DivRem(value, 50, out remainder);
if (result == 1)
returnString += "L";
value = (Byte) remainder;
// Get the tens digit.
result = Math.DivRem(value, 10, out remainder);
if (result > 0)
returnString += new String('X', result);
value = (Byte) remainder;
// Get the fives digit.
result = Math.DivRem(value, 5, out remainder);
if (result > 0)
returnString += "V";
value = (Byte) remainder;
// Add the ones digit.
if (remainder > 0)
returnString += new String('I', remainder);
// Check whether we have too many X characters.
int pos = returnString.IndexOf("XXXX");
if (pos >= 0) {
int xPos = returnString.IndexOf("L");
if (xPos >= 0 & xPos == pos - 1)
returnString = returnString.Replace("LXXXX", "XC");
else
returnString = returnString.Replace("XXXX", "XL");
}
// Check whether we have too many I characters
pos = returnString.IndexOf("IIII");
if (pos >= 0)
if (returnString.IndexOf("V") >= 0)
returnString = returnString.Replace("VIIII", "IX");
else
returnString = returnString.Replace("IIII", "IV");
return returnString;
}
// Use default for all other formatting.
if (obj is IFormattable)
return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
else
return obj.ToString();
}
}
public class Example
{
public static void Main()
{
int n = 10;
double value = 16.935;
DateTime day = DateTime.Now;
InterceptProvider provider = new InterceptProvider();
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ",
(DayOfWeek) DateTime.Now.DayOfWeek));
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
}
}
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
open System
open System.Globalization
type InterceptProvider() =
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then
this
else
null
interface ICustomFormatter with
member _.Format(format, obj, provider: IFormatProvider) =
// Display information about method call.
let formatString =
if format = null then "<null>" else format
printfn $"Provider: {provider.GetType().Name}, Object: %A{obj}, Format String: %s{formatString}"
if obj = null then
String.Empty
else
// If this is a byte and the "R" format string, format it with Roman numerals.
match obj with
| :? byte as value when formatString.ToUpper().Equals "R" ->
let mutable returnString = String.Empty
// Get the hundreds digit(s)
let struct (result, remainder) = Math.DivRem(value, 100uy)
if result > 0uy then
returnString <- String('C', int result)
let value = byte remainder
// Get the 50s digit
let struct (result, remainder) = Math.DivRem(value, 50uy)
if result = 1uy then
returnString <- returnString + "L"
let value = byte remainder
// Get the tens digit.
let struct (result, remainder) = Math.DivRem(value, 10uy)
if result > 0uy then
returnString <- returnString + String('X', int result)
let value = byte remainder
// Get the fives digit.
let struct (result, remainder) = Math.DivRem(value, 5uy)
if result > 0uy then
returnString <- returnString + "V"
let value = byte remainder
// Add the ones digit.
if remainder > 0uy then
returnString <- returnString + String('I', int remainder)
// Check whether we have too many X characters.
let pos = returnString.IndexOf "XXXX"
if pos >= 0 then
let xPos = returnString.IndexOf "L"
returnString <-
if xPos >= 0 && xPos = pos - 1 then
returnString.Replace("LXXXX", "XC")
else
returnString.Replace("XXXX", "XL")
// Check whether we have too many I characters
let pos = returnString.IndexOf "IIII"
if pos >= 0 then
returnString <-
if returnString.IndexOf "V" >= 0 then
returnString.Replace("VIIII", "IX")
else
returnString.Replace("IIII", "IV")
returnString
// Use default for all other formatting.
| :? IFormattable as x ->
x.ToString(format, CultureInfo.CurrentCulture)
| _ ->
string obj
let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
Imports System.Globalization
Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
Implements ICustomFormatter.Format
Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider, If(obj IsNot Nothing, obj, "<null>"), formatString)
If obj Is Nothing Then Return String.Empty
' If this is a byte and the "R" format string, format it with Roman numerals.
If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
Dim value As Byte = CByte(obj)
Dim remainder As Integer
Dim result As Integer
Dim returnString As String = String.Empty
' Get the hundreds digit(s)
result = Math.DivRem(value, 100, remainder)
If result > 0 Then returnString = New String("C"c, result)
value = CByte(remainder)
' Get the 50s digit
result = Math.DivRem(value, 50, remainder)
If result = 1 Then returnString += "L"
value = CByte(remainder)
' Get the tens digit.
result = Math.DivRem(value, 10, remainder)
If result > 0 Then returnString += New String("X"c, result)
value = CByte(remainder)
' Get the fives digit.
result = Math.DivRem(value, 5, remainder)
If result > 0 Then returnString += "V"
value = CByte(remainder)
' Add the ones digit.
If remainder > 0 Then returnString += New String("I"c, remainder)
' Check whether we have too many X characters.
Dim pos As Integer = returnString.IndexOf("XXXX")
If pos >= 0 Then
Dim xPos As Integer = returnString.IndexOf("L")
If xPos >= 0 And xPos = pos - 1 Then
returnString = returnString.Replace("LXXXX", "XC")
Else
returnString = returnString.Replace("XXXX", "XL")
End If
End If
' Check whether we have too many I characters
pos = returnString.IndexOf("IIII")
If pos >= 0 Then
If returnString.IndexOf("V") >= 0 Then
returnString = returnString.Replace("VIIII", "IX")
Else
returnString = returnString.Replace("IIII", "IV")
End If
End If
Return returnString
End If
' Use default for all other formatting.
If obj Is GetType(IFormattable)
Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
Else
Return obj.ToString()
End If
End Function
End Class
Module Example
Public Sub Main()
Dim n As Integer = 10
Dim value As Double = 16.935
Dim day As DateTime = Date.Now
Dim provider As New InterceptProvider()
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today",
CType(Date.Now.DayOfWeek, DayOfWeek)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
CByte(2), CByte(12), CByte(199)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}",
CByte(2), CByte(12), CByte(199)))
End Sub
End Module
' The example displays the following output:
' Provider: InterceptProvider, Object: 10, Format String: N0
' Provider: InterceptProvider, Object: 16.935, Format String: C2
' Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
' 10: $16.94 on 1/31/2013
'
' Provider: InterceptProvider, Object: Today: , Format String: <null>
' Provider: InterceptProvider, Object: Thursday, Format String: F
' Today: : Thursday
'
' Provider: InterceptProvider, Object: 2, Format String: X
' Provider: InterceptProvider, Object: 12, Format String: <null>
' Provider: InterceptProvider, Object: 199, Format String: <null>
' 2, 12, 199
'
' Provider: InterceptProvider, Object: 2, Format String: R
' Provider: InterceptProvider, Object: 12, Format String: R
' Provider: InterceptProvider, Object: 199, Format String: R
' II, XII, CXCIX
Často kladené dotazy
Proč doporučíte interpolaci řetězců při volání metody String.Format ?
Interpolace řetězců je:
Flexibilnější. Lze jej použít v libovolném řetězci bez nutnosti volání metody, která podporuje složené formátování. Jinak musíte volat metodu nebo jinou metodu Format , která podporuje složené formátování, například Console.WriteLine nebo StringBuilder.AppendFormat.
Čitelnější. Vzhledem k tomu, že výraz, který se má vložit do řetězce, se zobrazí v interpolovaném výrazu, nikoli v seznamu argumentů, jsou interpolované řetězce mnohem jednodušší kódovat a číst. Z důvodu větší čitelnosti mohou interpolované řetězce nahradit nejen volání metod složeného formátu, ale lze je také použít v operacích zřetězení řetězců k vytvoření stručnějšího a jasnějšího kódu.
Porovnání následujících dvou příkladů kódu znázorňuje nadřazenost interpolovaných řetězců nad zřetězením řetězců a voláním složených metod formátování. Použití více operací zřetězení řetězců v následujícím příkladu vytváří podrobný a pevně čitelný kód.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6];
output += "\n";
var date = DateTime.Now;
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
date, date.DayOfWeek);
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output =
names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6] + "\n"
let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example12
Public Sub Main()
Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " +
names(3) + ", " + names(4) + ", " + names(5) + ", " +
names(6)
output += vbCrLf
Dim dat = DateTime.Now
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
dat, dat.DayOfWeek)
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Naproti tomu použití interpolovaných řetězců v následujícím příkladu vytváří mnohem jasnější, stručnější kód než řetězcový příkaz zřetězení a volání Format metody v předchozím příkladu.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " +
$"{names[5]}, {names[6]}";
var date = DateTime.Now;
output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
open System
let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, {names[5]}, {names[6]}"
let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s"
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example13
Public Sub Main()
Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " +
$"{names(5)}, {names(6)}"
Dim dat = DateTime.Now
output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}."
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Kde najdu předdefinované formátovací řetězce?
Všechny celočíselné typy a typy s plovoucí desetinnou čárkou naleznete v tématu Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.
Hodnoty data a času najdete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času.
Hodnoty výčtu naleznete v tématu Výčtové formátovací řetězce.
Hodnoty TimeSpan najdete v tématu Standardní řetězce formátu TimeSpan a vlastní řetězce formátu TimeSpan.
Hodnoty Guid najdete v části Poznámky na Guid.ToString(String) stránce odkazu.
Návody řídit zarovnání výsledných řetězců, které nahrazují položky formátu?
Obecná syntaxe položky formátu je:
{index[,alignment][: formatString]}
where alignment is a signed integer that defines the field width. Pokud je tato hodnota záporná, text v poli je zarovnaný doleva. Pokud je text kladný, text je zarovnaný doprava.
Návody řídit počet číslic za oddělovačem desetinných míst?
Všechny standardní řetězce číselného formátu kromě " D" (které se používají pouze s celými čísly), "G", "R" a "X" umožňují specifikátor přesnosti, který definuje počet desetinných číslic ve výsledném řetězci. Následující příklad používá standardní číselné formátovací řetězce k řízení počtu desetinných číslic ve výsledném řetězci.
object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values)
{
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}\n",
Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
Console.WriteLine(result);
}
// The example displays output like the following:
// $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
//
// $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
//
// $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
open System
let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}\n", Convert.ToDouble(value), Convert.ToDouble(value) / 10000.)
|> printfn "%s"
// The example displays output like the following:
// $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
//
// $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
//
// $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
Module Example7
Public Sub Main()
Dim values() As Object = {1603, 1794.68235, 15436.14}
Dim result As String
For Each value In values
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}",
value, CDbl(value) / 10000)
Console.WriteLine(result)
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
'
' $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
'
' $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
Pokud používáte vlastní řetězec číselného formátu, použijte specifikátor formátu "0" k řízení počtu desetinných číslic ve výsledném řetězci, jak ukazuje následující příklad.
decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
Module Example8
Public Sub Main()
Dim value As Decimal = 16309.5436D
Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16309.54360 16,309.54 16309.544
Návody řídit počet integrálních číslic?
Ve výchozím nastavení operace formátování zobrazují pouze nenulové celočíselné číslice. Pokud formátujete celá čísla, můžete k řízení počtu číslic použít specifikátor přesnosti s řetězci standardního formátu "D" a "X".
int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
// 001326 0000052E
open System
let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// The example displays the following output:
// 001326 0000052E
Module Example10
Public Sub Main()
Dim value As Integer = 1326
Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 001326 0000052E
Můžete vypsat celé číslo nebo číslo s plovoucí desetinnou čárkou s úvodními nulami a vytvořit výsledný řetězec se zadaným počtem integrálních číslic pomocí specifikátoru vlastního číselného formátu "0", jak ukazuje následující příklad.
int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 00016342 00016342.000 0,000,016,342.0
open System
let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// The example displays the following output:
// 00016342 00016342.000 0,000,016,342.0
Module Example9
Public Sub Main()
Dim value As Integer = 16342
Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 00016342 00016342.000 0,000,016,342.0
Kolik položek můžu zahrnout do seznamu formátů?
Neexistuje žádný praktický limit. Druhý parametr Format(IFormatProvider, String, Object[]) metody je označen atributem ParamArrayAttribute , který umožňuje zahrnout jako seznam formátů buď seznam s oddělovači, nebo pole objektů.
Návody do výsledného řetězce zahrnout literály ("{" a "}")?
Jak například zabráníte volání následující metody vyvolání FormatException výjimky?
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose);
let result =
String.Format("The text has {0} '{' characters and {1} '}' characters.", nOpen, nClose)
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose)
Jednoduchá levá nebo pravá složená závorka se vždy interpretuje jako začátek nebo konec položky formátu. Aby bylo možné interpretovat doslova, musí být utekl. Uniknete závorce tak, že přidáte další složenou závorku ({{" a "}} místo {" a "}"), jako v následujícím volání metody:
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose);
Console.WriteLine(result);
let result =
String.Format("The text has {0} '{{' characters and {1} '}}' characters.", nOpen, nClose)
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose)
Dokonce i řídicí složené závorky jsou snadno chybně interpretovány. Doporučujeme zahrnout do seznamu formátů složené závorky a pomocí položek formátu je vložit do výsledného řetězce, jak ukazuje následující příklad.
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}");
Console.WriteLine(result);
let result =
String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.", nOpen, "{", nClose, "}")
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}")
Proč volání metody String.Format vyvolá výjimku FormatException?
Nejběžnější příčinou výjimky je, že index položky formátu neodpovídá objektu v seznamu formátů. Obvykle to znamená, že jste chybně očíslovali indexy formátovaných položek nebo jste zapomněli zahrnout objekt do seznamu formátů. Pokus o zahrnutí neuskutečeného levého nebo pravého závorky také vyvolá FormatExceptionznak . Občas je výjimka výsledkem překlepu; Typickou chybou je například chybný typ "[" (levá hranatá závorka) místo "{" (levá složená závorka).
Pokud metoda Format(System.IFormatProvider,System.String;System.Object[]) podporuje pole parametrů, proč můj kód vyvolá výjimku při použití pole?
Například následující kód vyvolá FormatException výjimku:
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);
open System
let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
Imports System.Collections.Generic
Module Example5
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
End Sub
End Module
Jedná se o problém překladu přetížení kompilátoru. Vzhledem k tomu, že kompilátor nemůže převést pole celých čísel na pole objektu, považuje celočíselné pole za jediný argument, takže volá metodu Format(String, Object) . Výjimka je vyvoláná, protože existují čtyři položky formátu, ale pouze jedna položka v seznamu formátů.
Vzhledem k tomu, že jazyk Visual Basic ani C# nemůže převést celočíselné pole na pole objektů, je nutné provést převod sami před voláním Format(String, Object[]) metody. Následující příklad obsahuje jednu implementaci.
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);
open System
let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
let number = rnd.Next 1001
numbers[i] <- number
total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
Imports System.Collections.Generic
Module Example6
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Dim values(numbers.Length - 1) As Object
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
End Sub
End Module
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro