Standardní řetězce formátu čísla

  • Článek

Řetězce standardního číselného formátu se používají pro formátování běžných číselných typů. Řetězec standardního číselného formátu má tvar [format specifier][precision specifier], kde:

  • Specifikátor formátu je jeden abecední znak, který určuje typ formátu čísla, například měna nebo procenta. Jakýkoli řetězec číselného formátu, který obsahuje více než jeden abecední znak, včetně prázdných znaků, je interpretován jako řetězec vlastního číselného formátu. Další informace najdete v tématu Vlastní řetězce číselného formátu.

  • 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í hodnota přesnosti 999 999 999. V .NET 6 je Int32.MaxValuemaximální hodnota přesnosti . V předchozích verzích rozhraní .NET může být přesnost v rozsahu od 0 do 99. Specifikátor přesnosti řídí počet číslic v řetězcovém vyjádření čísla. Neprovádí zaokrouhlení samotného čísla. K provedení operace zaokrouhlení použijte metodu Math.Ceiling, Math.Floornebo Math.Round .

    Když specifikátor přesnosti řídí počet desetinných míst ve výsledném řetězci, výsledný řetězec odráží číslo, které je zaokrouhleno na reprezentovatelný výsledek nejblíže k nekonečně přesnému výsledku. Pokud existují dva stejně podobné reprezentovatelné výsledky:

    • V .NET Framework a .NET Core až do .NET Core 2.0 modul runtime vybere výsledek s větší nejméně významnou číslicí (tj. pomocí MidpointRounding.AwayFromZero).
    • V .NET Core 2.1 a novějším modulu runtime vybere výsledek 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 výsledný řetězec vložit úvodními nebo koncovými mezerami, použijte funkci složeného formátování a definujte komponentu zarovnání v položce formátu.

Standardní řetězce číselného formátu podporují:

Tip

Můžete si stáhnout formátovací nástroj, aplikaci .NET Core model Windows Forms, která umožňuje použít formátovací řetězce na číselné hodnoty nebo hodnoty data a času a zobrazit výsledný řetězec. Zdrojový kód je k dispozici pro C# a Visual Basic.

Standardní specifikátory formátu

Následující tabulka popisuje standardní specifikátory číselného formátu a zobrazuje ukázkový výstup vytvořený jednotlivými specifikátory formátu. Další informace o použití řetězců standardního číselného formátu najdete v části Poznámky a v části Code example (Příklad kódu ) najdete ucelenou ilustraci jejich použití.

Výsledek formátovaného řetězce pro konkrétní jazykovou verzi se může od následujících příkladů lišit. Formát může mít vliv na nastavení operačního systému, uživatelská nastavení, proměnné prostředí a verze rozhraní .NET, kterou používáte. Například počínaje platformou .NET 5 se rozhraní .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 binárního formátu ("B").		 42 ("B")
-> 101010

255 ("b16")
-> 0000000011111111
"C" nebo "c" Měna Výsledek: hodnota měny.

Podporováno: všemi číselnými typy.

Specifikátor přesnosti: počet desetinných míst.

Výchozí specifikátor přesnosti: Definuje .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" Decimal Výsledek: celá čísla s volitelným záporným znaménkem.

Podporováno: pouze integrálovými 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ý) zápis Výsledek: exponenciální zápis.

Podporováno: všemi číselnými typy.

Specifikátor přesnosti: počet desetinných míst.

Výchozí specifikátor přesnosti: 6.

Další informace: Specifikátor exponenciálního formátu ("E")		 1052.0329112756 ("E", cs-CZ)
-> 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á desetinná čárka Výsledek: integrální a desítkové číslo s volitelným záporným znaménkem.

Podporováno: všemi číselnými typy.

Specifikátor přesnosti: počet desetinných míst.

Výchozí specifikátor přesnosti: Definováno nástrojem 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)
-> 1234,0

1234 ("F1", de-DE)
-> 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ápis s pevným nebo vědeckým zápisem.

Podporováno: všemi číselnými typy.

Specifikátor přesnosti: počet nejvýznamnějších číslic.

Výchozí specifikátor přesnosti: závisí na číselném typu.

Další informace: Specifikátor obecného formátu ("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)
-> 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šemi číselnými typy.

Specifikátor přesnosti: požadovaný počet desetinných míst.

Výchozí specifikátor přesnosti: Definováno nástrojem NumberFormatInfo.NumberDecimalDigits.

Další informace: Specifikátor čí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

-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é se symbolem procenta.

Podporováno: všemi číselnými typy.

Specifikátor přesnosti: požadovaný počet desetinných míst.

Výchozí specifikátor přesnosti: Definováno nástrojem 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í převod Výsledek: řetězec, který může použít operaci zpátečního převodu na stejné číslo.

Podporováno: Single, Doublea BigInteger.

Poznámka: Doporučeno pouze pro typ BigInteger . 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á hodnota Výsledek: šestnáctkový řetězec.

Podporováno: pouze integrálovými 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ý samostatný znak Neznámý specifikátor Výsledek: Vyvolá chybu FormatException za běhu.

Použití řetězců standardního číselného formátu

Poznámka

Příklady jazyka C# v tomto článku se spouští ve Try.NET vložené runner kódu a v testovacím prostředí. Výběrem tlačítka Spustit spusťte příklad v interaktivním okně. Jakmile spustíte kód, 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#.

Řetězec standardního čí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ě TryFormat nebo přetížení ToString metody, která má format parametr. Následující příklad formátuje číselnou hodnotu jako řetězec měny v aktuální jazykové verzi (v tomto případě jazykovou verzi en-US).

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

  • Lze ji zadat jako formatString argument v položce formátu, která se používá s metodami, jako String.Formatjsou , Console.WriteLinea StringBuilder.AppendFormat. Další informace najdete v tématu Složené formátování. Následující příklad používá položku formátu pro vložení hodnoty měny do řetězce.

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

    decimal value = 123.456m;
Console.WriteLine("Your account balance is {0:C2}.", value);
// 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 alignment argument pro určení šířky číselného pole a toho, jestli je jeho hodnota zarovnaná doprava nebo doleva. Následující příklad zarovná hodnotu měny doleva na pole o 28 znacích a hodnotu měny do pole o 14 znacích zarovná doprava.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                            static_cast<Decimal>(18794.16) };
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.16      

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

    Dim 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.16

  • Dá se zadat jako formatString argument v interpolované položce výrazu interpolovaného řetězce. Další informace najdete v článku Interpolace řetězců v referenční dokumentaci jazyka C# nebo v článku Interpolované řetězce v referenční dokumentaci jazyka Visual Basic.

Následující oddíly obsahují podrobné informace o jednotlivých řetězcích standardního čí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 integrální typy a pouze v rozhraní .NET 8 a novějších.

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 doplněno nulami po levé straně za účelem vytvoření počtu číslic, který je dán specifikátorem přesnosti.

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" (neboli měny) převede číslo na řetězec, který představuje peněžní částku. 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, výchozí přesnost je definována NumberFormatInfo.CurrencyDecimalDigits vlastností .

Pokud má formátovaná hodnota větší než zadaný nebo výchozí počet desetinných míst, je desetinná hodnota ve výsledném řetězci zaokrouhlena. Pokud je vpravo od zadaného počtu desetinných míst hodnota 5 nebo vyšší, bude poslední číslice ve výsledném řetězci zaokrouhlena směrem nahoru.

Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.

Vlastnost NumberFormatInfo Description
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ávorkou nebo NegativeSign vlastností.
NegativeSign Definuje záporné znaménko použité, pokud CurrencyNegativePattern označuje, že nejsou použity závorky.
CurrencySymbol Definuje symbol měny.
CurrencyDecimalDigits Definuje výchozí počet desítkových číslic 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 formá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
//       kr 12.345,679

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" (desítkové číslo) převede číslo na řetězec desítkových číslic (0-9), kterému předchází symbol mínus, je-li čí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 doplněno nulami po levé straně za účelem vytvoření počtu číslic, který je dán specifikátorem přesnosti. Pokud není zadán žádný specifikátor přesnosti, je výchozí hodnotou minimální hodnota požadovaná k vytvoření celého čísla bez počátečních nul.

Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Jak znázorňuje následující tabulka, jediná vlastnost ovlivňuje formátování výsledného řetězce.

Vlastnost NumberFormatInfo Description
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.

Následující příklad formá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

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)

Exponenciální specifikátor formátu ("E") převede číslo na řetězec ve formě "-d.ddd…E+ddd" nebo "-d.ddd…e+ddd", kde každé "d" označuje číslici (0-9). Pokud je číslo záporné, řetězec začíná symbolem mínus. Desetinné čárce předchází vždy přesně jedna číslice.

Specifikátor přesnosti označuje požadovaný počet číslic za desetinnou čárkou. Pokud specifikátor přesnosti vynecháte, je za desetinnou čárkou použit výchozí počet šesti číslic.

Velikost specifikátoru formátu označuje, zda má být před exponentem použita předpona "E" nebo "e". Exponent se skládá vždy ze znaménka plus nebo mínus a minimálně tří číslic. Aby byl tento minimální požadavek splněn, je exponent v případě potřeby doplněn nulami.

Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.

Vlastnost NumberFormatInfo Description
NegativeSign Definuje řetězec, který označuje, že číslo je záporné pro koeficient i pro exponent.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální číslice od desítkových číslic v koeficientu.
PositiveSign Definuje řetězec, který označuje, že exponent je kladný.

Následující příklad formá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

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 pevnou čárkou (F)

Specifikátor formátu s pevnou desetinnou čárkou ("F") převede číslo na řetězec ve tvaru "-ddd.ddd..." kde každé "d" označuje číslici (0-9). Pokud je číslo záporné, řetězec začíná symbolem mínus.

Specifikátor přesnosti označuje požadovaný počet desetinných míst. Pokud je specifikátor přesnosti vynechán, NumberFormatInfo.NumberDecimalDigits aktuální vlastnost poskytuje číselnou přesnost.

Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí vlastnosti objektu NumberFormatInfo , které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo Description
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 formátuje Double a Int32 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                        

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ápis s pevnou desetinou čárkou nebo vědecký zápis v závislosti na typu čísla a na tom, zda je k dispozici specifikátor přesnosti. Specifikátor přesnosti definuje maximální počet platných číslic, které mohou být zobrazeny ve výsledném řetězci. Pokud specifikátor přesnosti vynecháte nebo je specifikátor nulový, pak 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 zaokrouhlených zaokrouhlených k reprezentaci čísla
Single Nejmenší počet číslic zaokrouhlených zaokrouhlených k reprezentaci čísla (v rozhraní .NET Framework je výchozí hodnota G7)
Double Nejmenší počet číslic zaokrouhlených zaokrouhlených k reprezentaci čísla (v rozhraní .NET Framework je výchozí hodnota G15)
Decimal Nejmenší počet číslic zaokrouhlených zaokrouhlených k reprezentaci čísla

Zápis s pevnou desetinnou čárkou se používá v případě, že exponent, který by byl výsledkem vyjádření čísla ve vědeckém zápisu, je větší než -5 a menší než specifikátor přesnosti. Jinak se použije vědecký zápis. V případě potřeby obsahuje výsledek desetinnou čárku a koncové nuly po vynechání desetinné čárky. Pokud je k dispozici specifikátor přesnosti a počet platných číslic ve výsledku překračuje zadanou přesnost, pak jsou přebytečné koncové nuly odstraněny zaokrouhlením.

Pokud je však číslo a Decimal specifikátor přesnosti je vynechán, vždy se použije notace s pevným bodem a koncové nuly se zachovají.

Pokud použijete vědecký zápis, pak je před exponentem ve výsledku předpona "E", je-li specifikátor formát "G"; nebo předpona "e", je-li specifikátor formátu "g". Exponent obsahuje minimálně dvě číslice. Tím se liší od formátu pro vědecký zápis, který je vytvořen exponenciálním specifikátorem formátu, což zahrnuje minimálně tři číslice v exponentu.

Při použití s Double hodnotou specifikátor formátu "G17" zajistí, že se původní Double hodnota úspěšně zaokrouhlí. Je to proto, že Double je číslo s plovoucí desetinou čárkou kompatibilníbinary64 se standardem IEEE 754-2008, které poskytuje až 17 platných číslic přesnosti. V rozhraní .NET Framework doporučujeme místo specifikátoru formátu R použít jeho použití, protože v některých případech se "R" nepodaří úspěšně provést hodnoty dvojité přesnosti s plovoucí desetinou čárkou.

Při použití s Single hodnotou specifikátor formátu "G9" zajistí, že se původní Single hodnota úspěšně zaokrouhlí. Je to proto, že Single je číslo s plovoucí desetinou čárkou kompatibilníbinary32 se standardem IEEE 754-2008, které poskytuje až devět významných číslic přesnosti. Z důvodů výkonu doporučujeme místo specifikátoru formátu R použít jeho použití.

Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo Description
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 různé hodnoty s plovoucí desetinou čárkou pomocí obecného specifikátoru 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    

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 ve formě "-d,ddd,ddd.ddd…", kde "-" označuje symbol záporného čísla, je-li vyžadován, "d" označuje číslice (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 informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo Description
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čet integrálních číslic zobrazených mezi oddělovači skupin.
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 různé hodnoty s plovoucí desetinou čárkou se specifikátorem formátu čísla:

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 

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 procentuálního formátu ("P") vynásobí číslo 100 a převede ho na řetězec, který představuje procenta. Specifikátor přesnosti označuje požadovaný počet desetinných míst. Pokud je specifikátor přesnosti vynechán, 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.

Vlastnost NumberFormatInfo Description
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 pomocí specifikátoru formátu procent:

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 %

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 zpáteční cesty (R)

Specifikátor formátu R se pokouší 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 Halftypy , Single, Doublea BigInteger .

V rozhraní .NET Framework a ve verzích .NET Core starších než 3.0 se specifikátoru formátu R v některých případech nepodaří úspěšně provést hodnoty odezvy Double . Specifikátor formátu R pro obě Double hodnoty a Single nabízí relativně nízký výkon. Místo toho doporučujeme pro hodnoty použít specifikátor Double formátu "G17" a specifikátor formátu "G9" pro úspěšné obnovení Single hodnot.

BigInteger Pokud je hodnota formátována pomocí tohoto specifikátoru, její řetězcová reprezentace obsahuje všechny významné číslice v hodnotěBigInteger.

Ačkoli můžete použít také specifikátor přesnosti, bude ignorován. Pokud použijete tento specifikátor, má zpáteční převod přednost nad přesností. Výsledný řetězec je ovlivněn informacemi o formátování aktuálního NumberFormatInfo objektu. Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo Description
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 BigInteger hodnotu se specifikátorem formátu odezvy.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  



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é pomocí řetězce standardního číselného formátu "R" úspěšně nepřerušují, pokud jsou zkompilovány pomocí /platform:x64 přepínačů nebo /platform:anycpu a běží na 64bitových systémech. Další informace najdete v následujícím odstavci.

Chcete-li obejít problém s hodnotami formátovanými pomocí řetězce standardního číselného Double formátu R, který není úspěšně dokončen, pokud jsou kompilovány pomocí /platform:x64 přepínačů nebo /platform:anycpu a spuštěny v 64bitových systémech, můžete hodnoty formátovat Double pomocí standardního číselného řetězce "G17". Následující příklad používá řetězec formátu "R" s Double hodnotou, která úspěšně neprovádí odezvu, a také používá řetězec formátu "G17" k úspěšnému zaokrouhlování původní hodnoty:

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("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

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("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// 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':
//       0.6822871999174 = 0.68228719991740006: False
//
//       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':
'       0.6822871999174 = 0.68228719991740006: False
'
'       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. Velikost specifikátoru formátu označuje, zda pro šestnáctkové číslice, které jsou větší než 9, je nutné používat velká nebo malá písmena. Například pro vytvoření řetězce "ABCDEF" použijte formát "X", pro vytvoření řetězce "abcdef" použijte formát "x". 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 doplněno nulami po levé straně za účelem vytvoření počtu číslic, který je dán specifikátorem přesnosti.

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

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í řetězců standardního číselného formátu.

nastavení Ovládací panely

Nastavení v položce Místní a Jazykové možnosti v Ovládací panely ovlivnit výsledný řetězec vytvořený operací formátování. Tato nastavení slouží k inicializaci objektu přidruženého NumberFormatInfo 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) konstruktor je použit k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální systémová jazyková verze, veškeré přizpůsobení vytvořené místní a jazykové možnosti položka v Ovládací panely 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é jsou implicitně poskytovány aktuální jazykovou verzí nebo explicitně parametrem IFormatProvider metody, která vyvolává formátování. NumberFormatInfo Zadejte objekt nebo CultureInfo pro tento parametr.

Poznámka

Informace o přizpůsobení vzorů nebo řetězců používaných při formátování číselných hodnot najdete v NumberFormatInfo tématu třídy.

Celočíselné typy a číselné typy s plovoucí desetinou čárkou

Některé popisy specifikátorů standardního číselného formátu odkazují na integrální číselné typy nebo typy s plovoucí desetinnou čárkou. Celočíselné číselné typy jsou Byte, SByte, Int16, Int32, Int64UInt16, UInt32, , UInt64a BigInteger. Číselné typy s plovoucí desetinou čárkou jsou Decimal, HalfSingle, a Double.

Nekonečnosti s plovoucí desetinnou čárkou a NaN

Bez ohledu na formátovací řetězec platí, že pokud je hodnota Halftypu , Singlenebo Double typu s plovoucí desetinnou čárkou kladné nekonečno, záporné nekonečno nebo ne číslo (NaN), je formátovaný řetězec hodnotou příslušné PositiveInfinitySymbolvlastnosti , NegativeInfinitySymbolnebo NaNSymbol , která je určena aktuálně použitelným NumberFormatInfo objektem.

Příklad kódu

Následující příklad formátuje číselnou integrální hodnotu a hodnotu s plovoucí desetinnou čá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 ), ale přinesou by podobné výsledky pro kterýkoli z ostatních číselných základních typů (Byte, SByte, Int16, Int32Int64, UInt16, HalfBigIntegerUInt32UInt64Decimala ).SingleInt32

// 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: {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
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // 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.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        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é