Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Standardní řetězce číselného formátu se používají k formátování běžných číselných typů. Standardní řetězec číselného formátu má tvar [format specifier][precision specifier], kde:
Specifikátor formátu je jeden abecední znak, který určuje typ číselného formátu, například měnu nebo procento. Jakýkoli řetězec číselného formátu, který obsahuje více než jeden abecední znak, včetně prázdných znaků, se interpretuje jako vlastní řetězec číselného formátu. Další informace naleznete v tématu Vlastní číselné formátovací řetězce.
Specifikátor přesnosti je volitelné celé číslo, které ovlivňuje počet číslic ve výsledném řetězci. V .NET 7 a novějších verzích je maximální přesnost 999 999 999 999. V rozhraní .NET 6 je Int32.MaxValuemaximální hodnota přesnosti . V předchozích verzích .NET může přesnost být v rozsahu od 0 do 99. Specifikátor přesnosti řídí počet číslic v řetězcové reprezentaci čísla. Nezaokrouhluje číslo samotné. Chcete-li provést operaci zaokrouhlování, použijte metodu Math.Ceiling, Math.Floornebo Math.Round .
Pokud specifikátor přesnosti řídí počet desetinných číslic ve výsledném řetězci, bude výsledný řetězec odrážet číslo zaokrouhlené na reprezentovatelný výsledek nejblíže nekonečnému přesnému výsledku. Pokud existují dva stejně téměř reprezentovatelné výsledky:
- V rozhraní .NET Framework a .NET Core až .NET Core 2.0 modul runtime vybere výsledek s nejméně významnou číslicí (tj. pomocí MidpointRounding.AwayFromZero).
- V .NET Core 2.1 a novějším modul runtime vybere výsledek i s nejméně významnou číslicí (tj. pomocí MidpointRounding.ToEven).
Poznámka:
Specifikátor přesnosti určuje počet číslic ve výsledném řetězci. Pokud chcete vložit výsledný řetězec s počátečními nebo koncovými mezerami, použijte funkci složeného formátování a definujte součást šířky položky formátu.
Standardní řetězce číselného formátu jsou podporovány:
Některá přetížení
ToStringmetody všech číselných typů. Můžete například zadat řetězec Int32.ToString(String) číselného formátu pro metody a Int32.ToString(String, IFormatProvider) metody.Metoda
TryFormatvšech číselných typů, například Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) a Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).Funkce složeného formátování .NET, která se používá některými
WritemetodamiWriteLinea Console třídamiStreamWriter, metodou String.Format a metodouStringBuilder.AppendFormat. Funkce složeného formátu umožňuje zahrnout řetězcovou reprezentaci více datových položek do jednoho řetězce, určit šířku pole a zarovnat čísla do pole. Další informace naleznete v tématu Složené formátování.Interpolované řetězce v jazyce C# a Visual Basic, které poskytují zjednodušenou syntaxi ve srovnání s řetězci složeného formátu.
Doporučení
Můžete si stáhnout Nástroj pro formátování, aplikaci .NET Core Modelu Windows Forms, která umožňuje použít formátovací řetězce na číselné nebo hodnoty data a času a zobrazí výsledný řetězec. Zdrojový kód je k dispozici pro C# a Visual Basic.
Specifikátory standardního formátu
Následující tabulka popisuje standardní specifikátory číselného formátu a zobrazuje ukázkový výstup vytvořený specifikátorem jednotlivých formátů. Další informace o použití standardních řetězců číselného formátu najdete v části Poznámky a v části Příklad kódu najdete komplexní ilustraci jejich použití.
Výsledek formátovaného řetězce pro konkrétní jazykovou verzi se může lišit od následujících příkladů. Nastavení operačního systému, uživatelská nastavení, proměnné prostředí a verze .NET, kterou používáte, můžou mít vliv na formát. Například od .NET 5 se .NET snaží sjednotit kulturní formáty napříč platformami. Další informace najdete v tématu globalizace .NET a ICU.
| Specifikátor formátu | Název | Popis | Příklady |
|---|---|---|---|
| "B" nebo "b" | Binární | Výsledek: Binární řetězec. Podporováno: Pouze integrální typy (.NET 8+). Specifikátor přesnosti: Počet číslic ve výsledném řetězci. Další informace: Specifikátor formátu Binary ("B") |
42 ("B") Prodej -> 101010 255 ("B16") -> 0000000011111111 |
| "C" nebo "c" | Měna | Výsledek: Hodnota měny. Podporováno: Všechny číselné typy. Specifikátor přesnosti: Počet desetinných číslic. Výchozí specifikátor přesnosti: Definovaný parametrem NumberFormatInfo.CurrencyDecimalDigits. Další informace: Specifikátor formátu měny ("C"). |
123.456 ("C", en-US) -> \$123,46 123.456 ("C", fr-FR) -> 123,46 € 123.456 ("C", ja-JP) -> {123 -123.456 ("C3", en-US) -> (\$123,456) -123.456 ("C3", fr-FR) -> -123,456 € -123.456 ("C3", ja-JP) -> --123,456 |
| "D" nebo "d" | Desetinné číslo | Výsledek: Celočíselné číslice s volitelným záporným znaménkem. Podporováno: Pouze integrální typy. Specifikátor přesnosti: Minimální počet číslic. Výchozí specifikátor přesnosti: Minimální požadovaný počet číslic Další informace: Specifikátor formátu Decimal("D") |
1234 ("D") -> 1234 -1234 ("D6") -> -001234 |
| "E" nebo "e" | Exponenciální (vědecký) | Výsledek: Exponenciální zápis. Podporováno: Všechny číselné typy. Specifikátor přesnosti: Počet desetinných číslic. Výchozí specifikátor přesnosti: 6. Další informace: Specifikátor formátu exponenciálního formátu ("E"). |
1052.0329112756 ("E", en-US) -> 1.052033E+003 1052.0329112756 ("e", fr-FR) -> 1 052033e+003 -1052.0329112756 ("e2", en-US) -> -1,05e+003 -1052.0329112756 ("E2", fr-FR) -> -1 05E+003 |
| "F" nebo "f" | Pevný bod | Výsledek: Integrální a desetinná číslice s volitelným záporným znaménkem. Podporováno: Všechny číselné typy. Specifikátor přesnosti: Počet desetinných číslic. Výchozí specifikátor přesnosti: Definovaný parametrem NumberFormatInfo.NumberDecimalDigits. Další informace: Specifikátor formátu Fixed-Point ("F"). |
1234,567 ("F", en-US) -> 1234,57 1234.567 ("F", de-DE) -> 1234 57 1234 ("F1", en-US) Třída 1234.0> 1234 ("F1", de-DE) Prodej -> 1234,0 -1234,56 ("F4", en-US) -> -1234.5600 -1234,56 ("F4", de-DE) -> -1234 5600 |
| "G" nebo "g" | Obecné | Výsledek: Kompaktnější z pevné nebo vědecké notace. Podporováno: Všechny číselné typy. Specifikátor přesnosti: Počet významných číslic. Výchozí specifikátor přesnosti: Závisí na číselném typu. Další informace: Specifikátor formátu Obecné ("G"). |
-123.456 ("G", en-US) -> -123,456 -123,456 ("G", sv-SE) -> -123 456 123.4546 ("G4", en-US) -> 123,5 123.4546 ("G4", sv-SE) Celkový počet kusů 123,5> -1,234567890e-25 ("G", en-US) -> -1,23456789E-25 -1,234567890e-25 ("G", sv-SE) -> -1 23456789E-25 |
| "N" nebo "n" | Číslo | Výsledek: Integrální a desítkové číslice, oddělovače skupin a oddělovač desetinných míst s volitelným záporným znaménkem. Podporováno: Všechny číselné typy. Specifikátor přesnosti: Požadovaný počet desetinných míst Výchozí specifikátor přesnosti: Definovaný parametrem NumberFormatInfo.NumberDecimalDigits. Další informace: Specifikátor formátu číselného formátu ("N"). |
1234.567 ("N", en-US) -> 1 234,57 1234,567 ("N", ru-RU) -> 1 234 57 1234 ("N1", en-US) -> 1 234,0 1234 ("N1", ru-RU) -> 1 234,0 Kč -1234,56 ("N3", en-US) -> -1 234,560 -1234,56 ("N3", ru-RU) -> -1 234 560 |
| "P" nebo "p" | Procento | Výsledek: Číslo vynásobené číslem 100 a zobrazené symbolem procenta Podporováno: Všechny číselné typy. Specifikátor přesnosti: Požadovaný počet desetinných míst Výchozí specifikátor přesnosti: Definovaný parametrem NumberFormatInfo.PercentDecimalDigits. Další informace: Specifikátor formátu procent ("P"). |
1 ("P", en-US) -> 100,00 % 1 ("P", fr-FR) -> 100 00 % -0,39678 ("P1", en-US) -> -39,7 % -0,39678 ("P1", fr-FR) -> -39,7 % |
| "R" nebo "r" | Zpáteční cesta | Výsledek: Řetězec, který může zaokrouhlit na stejné číslo. Podporováno: Single, Doublea BigInteger. Poznámka: Doporučeno pouze pro BigInteger typ. Pro Double typy použijte "G17"; pro Single typy použijte "G9". Specifikátor přesnosti: Ignorováno. Další informace: Specifikátor formátu odezvy ("R") |
123456789.12345678 ("R") -> 123456789.12345678 -1234567890.12345678 ("R") -> -1234567890.1234567 |
| "X" nebo "x" | Šestnáctkový | Výsledek: Šestnáctkový řetězec. Podporováno: Pouze integrální typy. Specifikátor přesnosti: Počet číslic ve výsledném řetězci. Další informace: Specifikátor šestnáctkového formátu ("X"). |
255 ("X") -> FF -1 ("x") -> FF 255 ("x4") -> 00ff -1 ("X4") -> 00FF |
| Jakýkoli jiný jeden znak | Neznámý specifikátor | Výsledek: Vyvolá FormatException za běhu chybu. |
Použití standardních řetězců číselného formátu
Poznámka:
Příklady jazyka C# v tomto článku se spouštějí v Try.NET inline code runner a playground. Vyberte tlačítko Spustit a spusťte příklad v interaktivním okně. Jakmile kód spustíte, můžete ho upravit a spustit upravený kód tak, že znovu vyberete Spustit . Upravený kód se buď spustí v interaktivním okně, nebo pokud kompilace selže, zobrazí se v interaktivním okně všechny chybové zprávy kompilátoru jazyka C#.
Standardní řetězec číselného formátu lze použít k definování formátování číselné hodnoty jedním z následujících způsobů:
Může být předán metodě
TryFormatnebo přetíženíToStringmetody, která máformatparametr. Následující příklad formátuje číselnou hodnotu jako řetězec měny v aktuální jazykové verzi (v tomto případě en-US jazykové verze).decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); // Displays $123.46Dim value As Decimal = 123.456d Console.WriteLine(value.ToString("C2")) ' Displays $123.46Lze jej zadat jako
formatStringargument v položce formátu použité s těmito metodami, jako String.Formatje , Console.WriteLinea StringBuilder.AppendFormat. Další informace naleznete v tématu Složené formátování. Následující příklad používá položku formátu k vložení hodnoty měny do řetězce.decimal value = 123.456m; Console.WriteLine($"Your account balance is {value:C2}."); // Displays "Your account balance is $123.46."Dim value As Decimal = 123.456d Console.WriteLine("Your account balance is {0:C2}.", value) ' Displays "Your account balance is $123.46."Volitelně můžete zadat
alignmentargument, který určuje šířku číselného pole a jestli je jeho hodnota zarovnaná doprava nebo doleva. Následující příklad zarovná hodnotu měny do pole s 28 znaky a zarovná hodnotu měny do pole s 14 znaky.decimal[] amounts = { 16305.32m, 18794.16m }; Console.WriteLine(" Beginning Balance Ending Balance"); Console.WriteLine(" {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]); // Displays: // Beginning Balance Ending Balance // $16,305.32 $18,794.16Dim amounts() As Decimal = {16305.32d, 18794.16d} Console.WriteLine(" Beginning Balance Ending Balance") Console.WriteLine(" {0,-28:C2}{1,14:C2}", amounts(0), amounts(1)) ' Displays: ' Beginning Balance Ending Balance ' $16,305.32 $18,794.16Dá se zadat jako
formatStringargument v interpolované položce výrazu interpolovaného řetězce. Další informace najdete v článku o interpolaci řetězců v referenční dokumentaci jazyka C# nebo článku Interpolované řetězce v referenční dokumentaci jazyka Visual Basic.
Následující části obsahují podrobné informace o jednotlivých standardních řetězcích číselného formátu.
Specifikátor binárního formátu (B)
Specifikátor binárního formátu ("B") převede číslo na řetězec binárních číslic. Tento formát je podporován pouze pro celočíselné typy a pouze pro .NET 8 nebo novější.
Specifikátor přesnosti označuje minimální počet číslic požadovaných ve výsledném řetězci. V případě potřeby je číslo vyplněno nulami vlevo, aby se vytvořil počet číslic zadaný specifikátorem přesnosti.
Kladné BigIntegerhodnoty vždy mají úvodní nulu, aby se odlišily od záporných hodnot. Tím zajistíte výstupní odezvu na původní hodnotu při analýze. Například číslo 3 převedené specifikátorem "B2" formátu je "011". Je to proto, že binární číslo "11" představuje zápornou hodnotu -1, protože se interpretuje jako číslo s přesně 2 bity z důvodu "B2" formátu.
Výsledný řetězec není ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu.
Specifikátor formátu měny (C)
Specifikátor formátu "C" (nebo měna) převede číslo na řetězec, který představuje částku měny. Specifikátor přesnosti označuje požadovaný počet desetinných míst ve výsledném řetězci. Pokud je specifikátor přesnosti vynechán, je výchozí přesnost definována NumberFormatInfo.CurrencyDecimalDigits vlastností.
Pokud má hodnota, která se má formátovat, větší než zadaný nebo výchozí počet desetinných míst, zaokrouhlí se ve výsledném řetězci desetinná hodnota. Pokud je hodnota napravo od zadaného počtu desetinných míst 5 nebo větší, zaokrouhlí se poslední číslice ve výsledném řetězci směrem od nuly.
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| CurrencyPositivePattern | Definuje umístění symbolu měny pro kladné hodnoty. |
| CurrencyNegativePattern | Definuje umístění symbolu měny pro záporné hodnoty a určuje, zda je záporné znaménko reprezentováno závorky nebo NegativeSign vlastností. |
| NegativeSign | Definuje záporné znaménko použité v případě CurrencyNegativePattern , že se nepoužívají závorky. |
| CurrencySymbol | Definuje symbol měny. |
| CurrencyDecimalDigits | Definuje výchozí počet desetinných míst v hodnotě měny. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti. |
| CurrencyDecimalSeparator | Definuje řetězec, který odděluje integrální a desítkové číslice. |
| CurrencyGroupSeparator | Definuje řetězec, který odděluje skupiny integrálních čísel. |
| CurrencyGroupSizes | Definuje počet celých číslic, které se zobrazují ve skupině. |
Následující příklad naformátuje Double hodnotu se specifikátorem formátu měny:
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3",
CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
// $12,345.68
// $12,345.679
// 12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))
Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))
Console.WriteLine(value.ToString("C3", _
CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
' $12,345.68
' $12,345.679
' kr 12.345,679
Specifikátor formátu desetinných míst (D)
Specifikátor formátu "D" (nebo desítkové číslo) převede číslo na řetězec desetinných číslic (0–9), předponu znaménko minus, pokud je číslo záporné. Tento formát je podporován pouze pro integrální typy.
Specifikátor přesnosti označuje minimální počet číslic požadovaných ve výsledném řetězci. V případě potřeby je číslo vyplněno nulami vlevo, aby se vytvořil počet číslic zadaný specifikátorem přesnosti. Pokud není zadán žádný specifikátor přesnosti, výchozí hodnota je minimální hodnota požadovaná k reprezentaci celého čísla bez počátečních nul.
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Jak ukazuje následující tabulka, jedna vlastnost ovlivňuje formátování výsledného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
Následující příklad naformátuje Int32 hodnotu se specifikátorem desítkového formátu.
int value;
value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345
value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer
value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345
Console.WriteLine(value.ToString("D8"))
' Displays 00012345
value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345
Specifikátor exponenciálního formátu (E)
Specifikátor exponenciálního formátu ("E") převede číslo na řetězec formuláře "-d.ddd... E+ddd" nebo "-d.ddd... e+ddd", kde každý "d" označuje číslici (0-9). Řetězec začíná znaménkem mínus, pokud je číslo záporné. Přesně jedna číslice vždy předchází desetinné bodě.
Specifikátor přesnosti označuje požadovaný počet číslic za desetinnou čárkou. Pokud je specifikátor přesnosti vynechán, použije se výchozí hodnota šesti číslic za desetinnou čárkou.
Případ specifikátoru formátu označuje, zda má být předpona exponentu "E" nebo "e". Exponent se vždy skládá ze znaménka plus nebo minus a minimálně tří číslic. Exponent je v případě potřeby vycpán nulami, které splňují toto minimum.
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné pro koeficient i exponent. |
| NumberDecimalSeparator | Definuje řetězec, který odděluje integrální číslici od desítkových číslic v koeficientu. |
| PositiveSign | Definuje řetězec, který označuje, že exponent je kladný. |
Následující příklad naformátuje Double hodnotu se specifikátorem exponenciálního formátu:
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004
Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004
Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004
Console.WriteLine(value.ToString("E",
CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004
Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004
Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004
Console.WriteLine(value.ToString("E", _
CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004
Specifikátor formátu s pevným bodem (F)
Specifikátor formátu pevného bodu ("F") převede číslo na řetězec formuláře "-ddd.dddd..." kde každá "d" označuje číslici (0-9). Řetězec začíná znaménkem mínus, pokud je číslo záporné.
Specifikátor přesnosti označuje požadovaný počet desetinných míst. Pokud je specifikátor přesnosti vynechán, aktuální NumberFormatInfo.NumberDecimalDigits vlastnost poskytuje číselnou přesnost.
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí vlastnosti objektu NumberFormatInfo , který řídí formátování výsledného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
| NumberDecimalSeparator | Definuje řetězec, který odděluje integrální číslice od desítkových číslic. |
| NumberDecimalDigits | Definuje výchozí počet desítkových číslic. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti. |
Následující příklad naformátuje a DoubleInt32 hodnotu se specifikátorem formátu s pevným bodem:
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
CultureInfo.InvariantCulture));
// Displays 17843.00
integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
CultureInfo.InvariantCulture));
// Displays -29541.000
double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934
doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2
Console.WriteLine(doubleNumber.ToString("F3",
CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00
integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000
Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934
doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2
Console.WriteLine(doubleNumber.ToString("F3", _
CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199
Specifikátor obecného formátu (G)
Specifikátor obecného formátu ("G") převede číslo na kompaktnější z pevné nebo vědecké notace v závislosti na typu čísla a na tom, zda je přítomen specifikátor přesnosti. Specifikátor přesnosti definuje maximální počet významných číslic, které se mohou objevit ve výsledném řetězci. Pokud je specifikátor přesnosti vynechán nebo nula, typ čísla určuje výchozí přesnost, jak je uvedeno v následující tabulce.
| Číselný typ | Výchozí přesnost |
|---|---|
| Byte nebo SByte | 3 číslice |
| Int16 nebo UInt16 | 5 číslic |
| Int32 nebo UInt32 | 10 číslic |
| Int64 | 19 číslic |
| UInt64 | 20 číslic |
| BigInteger | Neomezené (stejné jako "R") |
| Half | Nejmenší počet číslic s možnou odezvou zaokrouhlení, které představují číslo |
| Single | Nejmenší počet číslic, které představují číslo (v rozhraní .NET Framework, G7 je výchozí) |
| Double | Nejmenší počet číslic, které představují číslo (v rozhraní .NET Framework, G15 je výchozí) |
| Decimal | Nejmenší počet číslic s možnou odezvou zaokrouhlení, které představují číslo |
Zápis s pevným bodem se použije, pokud exponent, který by byl výsledkem vyjádření čísla ve vědeckém zápisu, větší než -5 a menší než specifikátor přesnosti; jinak se použije vědecký zápis. Výsledek obsahuje v případě potřeby desetinnou čárku a koncové nuly po vynechání desetinné čárky. Pokud je specifikátor přesnosti přítomný a počet významných číslic ve výsledku překročí zadanou přesnost, nadbytečné koncové číslice se odeberou zaokrouhlením.
Pokud je ale číslo a Decimal specifikátor přesnosti vynechá, použije se zápis s pevným bodem a koncové nuly se zachovají.
Pokud se použije vědecký zápis, je exponent ve výsledku předponou "E", pokud je specifikátor formátu "G" nebo "e", pokud specifikátor formátu je "g". Exponent obsahuje minimálně dvě číslice. Liší se od formátu vědeckého zápisu, který je vytvořen specifikátorem exponenciálního formátu, který zahrnuje minimálně tři číslice v exponentu.
Při použití s Double hodnotou specifikátor formátu "G17" zajistí, že původní Double hodnota úspěšně zaokrouhluje. Důvodem je to, že Double číslo s plovoucí desetinnou čárkou (binary64) vyhovující standardu IEEE 754-2008 (s plovoucí desetinnou čárkou), které poskytuje až 17 významných číslic přesnosti. V rozhraní .NET Framework doporučujeme místo specifikátoru formátu "R" použít, protože v některých případech se "R" nepodaří úspěšně provést dvojité přepojené hodnoty s plovoucí desetinnou čárkou.
Při použití s Single hodnotou specifikátor formátu "G9" zajistí, že původní Single hodnota úspěšně zaokrouhluje. Důvodem je to, že Single číslo s plovoucí desetinnou čárkou (binary32s plovoucí desetinnou čárkou) vyhovující standardu IEEE 754-2008, které poskytuje až devět významných číslic přesnosti. Z důvodů výkonu doporučujeme použít místo specifikátoru formátu "R".
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
| NumberDecimalSeparator | Definuje řetězec, který odděluje integrální číslice od desítkových číslic. |
| PositiveSign | Definuje řetězec, který označuje, že exponent je kladný. |
Následující příklad formátuje seřazené hodnoty s plovoucí desetinou čárkou se specifikátorem obecného formátu:
double number;
number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 12345.6789
Console.WriteLine(number.ToString("G",
CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68
number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06
number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023
number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03
number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416
Dim number As Double
number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 12345.6789
Console.WriteLine(number.ToString("G", _
CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68
number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06
Console.WriteLine(number.ToString("G", _
CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06
number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023
number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03
number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416
Specifikátor číselného formátu (N)
Specifikátor číselného formátu ("N") převede číslo na řetězec formuláře "-d,ddd,ddd.ddd...", kde "-" označuje v případě potřeby záporný symbol čísla, "d" označuje číslici (0–9), "," označuje oddělovač skupin a "." označuje symbol desetinné čárky. Specifikátor přesnosti označuje požadovaný počet číslic za desetinnou čárkou. Pokud je specifikátor přesnosti vynechán, je počet desetinných míst definován aktuální NumberFormatInfo.NumberDecimalDigits vlastností.
Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
| NumberNegativePattern | Definuje formát záporných hodnot a určuje, zda je záporné znaménko reprezentováno závorky nebo NegativeSign vlastností. |
| NumberGroupSizes | Definuje početintegrch |
| NumberGroupSeparator | Definuje řetězec, který odděluje skupiny integrálních čísel. |
| NumberDecimalSeparator | Definuje řetězec, který odděluje integrální a desítkové číslice. |
| NumberDecimalDigits | Definuje výchozí počet desítkových číslic. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti. |
Následující příklad formátuje seřazené hodnoty s plovoucí desetinou čárkou se specifikátorem číselného formátu:
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7
int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7
Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0
Specifikátor formátu procent (P)
Specifikátor formátu procenta ("P") vynásobí číslo číslem 100 a převede ho na řetězec, který představuje procento. Specifikátor přesnosti označuje požadovaný počet desetinných míst. Pokud specifikátor přesnosti vynecháte, použije se výchozí číselná přesnost zadaná aktuální PercentDecimalDigits vlastností.
Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| PercentPositivePattern | Definuje umístění symbolu procenta pro kladné hodnoty. |
| PercentNegativePattern | Definuje umístění symbolu procenta a záporného symbolu pro záporné hodnoty. |
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
| PercentSymbol | Definuje symbol procenta. |
| PercentDecimalDigits | Definuje výchozí počet desetinných míst v procentuální hodnotě. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti. |
| PercentDecimalSeparator | Definuje řetězec, který odděluje integrální a desítkové číslice. |
| PercentGroupSeparator | Definuje řetězec, který odděluje skupiny integrálních čísel. |
| PercentGroupSizes | Definuje počet celých číslic, které se zobrazují ve skupině. |
Následující příklad formátuje hodnoty s plovoucí desetinou čárkou se specifikátorem procentuálního formátu:
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %
Specifikátor formátu odezvy (R)
Specifikátor formátu odezvy ("R") se pokusí zajistit, aby se číselná hodnota převedená na řetězec parsovala zpět na stejnou číselnou hodnotu. Tento formát je podporován pouze pro Half, Single, Doublea BigInteger typy.
V rozhraní .NET Framework a ve verzích .NET Core starších než 3.0 se specifikátor formátu "R" v některých případech nepodaří úspěšně přepojit Double hodnoty. Specifikátor formátu "R" pro obě Double hodnoty Single nabízí relativně nízký výkon. Místo toho doporučujeme použít specifikátor formátu "G17" pro Double hodnoty a specifikátor formátu "G9" k úspěšnému zaokrouhlování Single hodnot.
BigInteger Pokud je hodnota formátována pomocí tohoto specifikátoru, její řetězcové vyjádření obsahuje všechny významné číslice v hodnotěBigInteger.
I když můžete použít specifikátor přesnosti, bude ignorován. Při použití tohoto specifikátoru mají přednost před odezvou. Výsledný řetězec je ovlivněn formátováním informací aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.
| NumberFormatInfo – vlastnost | Popis |
|---|---|
| NegativeSign | Definuje řetězec, který označuje, že číslo je záporné. |
| NumberDecimalSeparator | Definuje řetězec, který odděluje integrální číslice od desítkových číslic. |
| PositiveSign | Definuje řetězec, který označuje, že exponent je kladný. |
Následující příklad naformátuje BigInteger hodnotu se specifikátorem formátu odezvy.
using System;
using System.Numerics;
public class Example
{
public static void Main()
{
var value = BigInteger.Pow(Int64.MaxValue, 2);
Console.WriteLine(value.ToString("R"));
}
}
// The example displays the following output:
// 85070591730234615847396907784232501249
Imports System.Numerics
Module Example
Public Sub Main()
Dim value = BigInteger.Pow(Int64.MaxValue, 2)
Console.WriteLine(value.ToString("R"))
End Sub
End Module
' The example displays the following output:
' 85070591730234615847396907784232501249
Důležité
V některých případech Double se hodnoty formátované standardním řetězcem číselného formátu R úspěšně neproběhnou, pokud jsou zkompilovány pomocí /platform:x64 přepínačů nebo /platform:anycpu přepínačů a běží na 64bitových systémech. Další informace najdete v následujícím odstavci.
Chcete-li vyřešit problém s hodnotami naformátovaným standardním řetězcem číselného Double formátu "R", pokud je zkompilován pomocí /platform:x64 nebo /platform:anycpu přepínačů a spuštěn na 64bitových systémech, můžete hodnoty formátovat Double pomocí standardního řetězce číselného formátu "G17". Následující příklad používá řetězec formátu "R" s Double hodnotou, která neprovádí úspěšnou odezvu, a také pomocí řetězce formátu "G17" úspěšně zaokrouhluje původní hodnotu:
Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
CultureInfo.InvariantCulture);
Console.WriteLine($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");
Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
CultureInfo.InvariantCulture);
Console.WriteLine($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
// Attempting to round-trip a Double with 'R':
// .NET Framework:
// 0.6822871999174 = 0.68228719991740006: False
// .NET:
// 0.6822871999174 = 0.6822871999174: True
//
// Attempting to round-trip a Double with 'G17':
// 0.6822871999174 = 0.6822871999174: True
Imports System.Globalization
Module Example
Public Sub Main()
Console.WriteLine("Attempting to round-trip a Double with 'R':")
Dim initialValue As Double = 0.6822871999174
Dim valueString As String = initialValue.ToString("R",
CultureInfo.InvariantCulture)
Dim roundTripped As Double = Double.Parse(valueString,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped, initialValue.Equals(roundTripped))
Console.WriteLine()
Console.WriteLine("Attempting to round-trip a Double with 'G17':")
Dim valueString17 As String = initialValue.ToString("G17",
CultureInfo.InvariantCulture)
Dim roundTripped17 As Double = double.Parse(valueString17,
CultureInfo.InvariantCulture)
Console.WriteLine("{0:R} = {1:R}: {2}",
initialValue, roundTripped17, initialValue.Equals(roundTripped17))
End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
' Attempting to round-trip a Double with 'R':
' .NET Framework:
' 0.6822871999174 = 0.68228719991740006: False
' .NET:
' 0.6822871999174 = 0.6822871999174: True
'
' Attempting to round-trip a Double with 'G17':
' 0.6822871999174 = 0.6822871999174: True
Specifikátor šestnáctkového formátu (X)
Specifikátor šestnáctkového formátu ("X") převede číslo na řetězec šestnáctkových číslic. Případ specifikátoru formátu označuje, zda použít velká nebo malá písmena pro šestnáctkové číslice, které jsou větší než 9. Například pomocí "X" vytvoříte "ABCDEF" a "x" k vytvoření "abcdef". Tento formát je podporován pouze pro integrální typy.
Specifikátor přesnosti označuje minimální počet číslic požadovaných ve výsledném řetězci. V případě potřeby je číslo vyplněno nulami vlevo, aby se vytvořil počet číslic zadaný specifikátorem přesnosti.
Kladné BigIntegerhodnoty vždy mají úvodní nulu, aby se odlišily od záporných hodnot. Tím zajistíte výstupní odezvu na původní hodnotu při analýze. Například číslo převedené specifikátorem F formátu je "X1" proto, že šestnáctkové číslo 0F představuje zápornou hodnotu F.-1
Výsledný řetězec není ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu.
Následující příklad formátuje Int32 hodnoty se specifikátorem šestnáctkového formátu.
int value;
value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E
value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer
value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E
value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15
Poznámky
Tato část obsahuje další informace o použití standardních řetězců číselného formátu.
Nastavení Ovládacích panelů
Nastavení položky Místní a Jazykové možnosti v Ovládacích panelech ovlivňují výsledný řetězec vytvořený operací formátování. Tato nastavení slouží k inicializaci objektu NumberFormatInfo přidruženého k aktuální jazykové verzi, která poskytuje hodnoty používané k řízení formátování. Počítače, které používají různá nastavení, generují různé výsledné řetězce.
Kromě toho, pokud CultureInfo(String) se konstruktor používá k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální systémová jazyková verze, všechny přizpůsobení vytvořené položkou Místní a jazykové možnosti v Ovládacích panelech budou použity na nový CultureInfo objekt. Konstruktor můžete použít CultureInfo(String, Boolean) k vytvoření objektu CultureInfo , který neodráží vlastní nastavení systému.
Vlastnosti NumberFormatInfo
Formátování je ovlivněno vlastnostmi aktuálního NumberFormatInfo objektu, která je implicitně poskytována aktuální jazykovou verzí nebo explicitně IFormatProvider parametrem metody, která vyvolá formátování. NumberFormatInfo Zadejte objekt nebo CultureInfo objekt pro tento parametr.
Poznámka:
Informace o přizpůsobení vzorů nebo řetězců použitých při formátování číselných hodnot najdete v NumberFormatInfo tématu třídy.
Integrální a číselné typy s plovoucí desetinou čárkou
Některé popisy specifikátorů standardního číselného formátu odkazují na integrální nebo číselné typy s plovoucí desetinou čárkou. Integrální číselné typy jsou Byte, , SByte, Int16Int32Int64UInt16, UInt32, , UInt64a .BigInteger Číselné typy s plovoucí desetinou čárkou jsou Decimal, Half, Singlea Double.
Infinity s plovoucí desetinnou čárkou a NaN
Bez ohledu na formátovací řetězec, pokud hodnota Halftypu , Singlenebo Double plovoucí desetinná čárka je kladné nekonečno, záporné nekonečno nebo není číslo (NaN), formátovaný řetězec je hodnota odpovídající PositiveInfinitySymbol, NegativeInfinitySymbolnebo NaNSymbol vlastnost, která je určena aktuálně použitelným NumberFormatInfo objektem.
Příklad kódu
Následující příklad formátuje integrální a číselnou hodnotu s plovoucí desetinou čárkou pomocí jazykové verze en-US a všech specifikátorů standardního číselného formátu. V tomto příkladu se používají dva konkrétní číselné typy (Double a Int32), ale výsledky by byly podobné pro kterýkoli z ostatních číselných základních typů (Byte, SByte, , Int16, Int32Int64, UInt16UInt32, UInt64, , , BigInteger, , DecimalHalfa Single).
// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");
// Output floating point values
double floating = 10761.937554;
Console.WriteLine($"C: {floating.ToString("C", ci)}"); // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}"); // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}"); // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}"); // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}"); // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}"); // Displays "R: 10761.937554"
Console.WriteLine();
// Output integral values
int integral = 8395;
Console.WriteLine($"C: {integral.ToString("C", ci)}"); // Displays "C: $8,395.00"
Console.WriteLine($"D: {integral.ToString("D6", ci)}"); // Displays "D: 008395"
Console.WriteLine($"E: {integral.ToString("E03", ci)}"); // Displays "E: 8.395E+003"
Console.WriteLine($"F: {integral.ToString("F01", ci)}"); // Displays "F: 8395.0"
Console.WriteLine($"G: {integral.ToString("G", ci)}"); // Displays "G: 8395"
Console.WriteLine($"N: {integral.ToString("N01", ci)}"); // Displays "N: 8,395.0"
Console.WriteLine($"P: {(integral/10000.0).ToString("P02", ci)}"); // Displays "P: 83.95 %"
Console.WriteLine($"X: 0x{integral.ToString("X", ci)}"); // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On
Imports System.Globalization
Imports System.Threading
Module NumericFormats
Public Sub Main()
' Display string representations of numbers for en-us culture
Dim ci As New CultureInfo("en-us")
' Output floating point values
Dim floating As Double = 10761.937554
Console.WriteLine("C: {0}", _
floating.ToString("C", ci)) ' Displays "C: $10,761.94"
Console.WriteLine("E: {0}", _
floating.ToString("E03", ci)) ' Displays "E: 1.076E+004"
Console.WriteLine("F: {0}", _
floating.ToString("F04", ci)) ' Displays "F: 10761.9376"
Console.WriteLine("G: {0}", _
floating.ToString("G", ci)) ' Displays "G: 10761.937554"
Console.WriteLine("N: {0}", _
floating.ToString("N03", ci)) ' Displays "N: 10,761.938"
Console.WriteLine("P: {0}", _
(floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
Console.WriteLine("R: {0}", _
floating.ToString("R", ci)) ' Displays "R: 10761.937554"
Console.WriteLine()
' Output integral values
Dim integral As Integer = 8395
Console.WriteLine("C: {0}", _
integral.ToString("C", ci)) ' Displays "C: $8,395.00"
Console.WriteLine("D: {0}", _
integral.ToString("D6")) ' Displays "D: 008395"
Console.WriteLine("E: {0}", _
integral.ToString("E03", ci)) ' Displays "E: 8.395E+003"
Console.WriteLine("F: {0}", _
integral.ToString("F01", ci)) ' Displays "F: 8395.0"
Console.WriteLine("G: {0}", _
integral.ToString("G", ci)) ' Displays "G: 8395"
Console.WriteLine("N: {0}", _
integral.ToString("N01", ci)) ' Displays "N: 8,395.0"
Console.WriteLine("P: {0}", _
(integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}", _
integral.ToString("X", ci)) ' Displays "X: 0x20CB"
Console.WriteLine()
End Sub
End Module
Viz také
Spolupracujte s námi na GitHubu
Zdroj tohoto obsahu najdete na GitHubu, kde můžete také vytvářet a kontrolovat problémy a žádosti o přijetí změn. Další informace najdete v našem průvodci pro přispěvatele.
