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

Řetězce standardního číselného formátu se používají pro 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ů, 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 6 a novějších verzích je Int32.MaxValuemaximální přesnost hodnota . 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. Neprovádí zaokrouhlení samotného čísla. K provedení operace zaokrouhlení 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, výsledný řetězec odráží číslo zaokrouhlené na reprezentovatelný výsledek nejblíže k 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 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 ú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 jsou podporovány:

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 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 specifikátory standardního čí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
"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: Definovaný parametrem NumberFormatInfo.CurrencyDecimalDigits.

Další informace: Specifikátor formátu Měna ("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 formátu Exponential ("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á 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: 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)
-> 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ší pevný bod nebo vědecký zápis.

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 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)
-> 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: Definovaný parametrem NumberFormatInfo.NumberDecimalDigits.

Další informace: Specifikátor formátu čísel ("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: Definovaný parametrem NumberFormatInfo.PercentDecimalDigits.

Další informace: Specifikátor formátu Procenta ("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 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á 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 formátu HexaDecimal ("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á za FormatException 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í 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ě TryFormat nebo přetížení ToString metody, která má format parametr. Následující příklad naformá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 jej zadat jako formatString argument v položce formátu použité s těmito metodami, jako je String.Format, 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 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, který určuje šířku číselného pole a jestli je její 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.

    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 odkazu jazyka C# nebo v článku interpolované řetězce v Visual Basic odkazu.

Následující oddíly obsahují podrobné informace o jednotlivých řetězcích standardního číselného formátu.

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 specifikátor přesnosti vynecháte, je výchozí přesnost 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 má vliv na formátování aktuálního objektu NumberFormatInfo . Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.

Vlastnost NumberFormatInfo 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é, pokud CurrencyNegativePattern označuje, že se nepoužívají 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 naformátuje Double hodnotu 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 má vliv na formátování aktuálního objektu NumberFormatInfo . Jak znázorňuje následující tabulka, jediná vlastnost ovlivňuje formátování výsledného řetězce.

Vlastnost NumberFormatInfo 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 desetinného čísla.

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 má vliv na formátování aktuálního objektu NumberFormatInfo . Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.

Vlastnost NumberFormatInfo Popis
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 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
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ými body (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). 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, aktuální NumberFormatInfo.NumberDecimalDigits vlastnost poskytuje číselnou přesnost.

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

Vlastnost NumberFormatInfo 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 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 pevné nebo vědecké notace v závislosti na typu čísla a 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 3 číslice
Single 7 číslic
Double 15 číslic
Decimal 29 číslic

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 ale číslo a Decimal specifikátor přesnosti vynechá, použije se vždy zápis 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í úspěšné zaokrouhlení původní Double hodnoty. Důvodem je to, že Double číslo s dvojitou přesností kompatibilní s plovoucí desetinou čárkou (binary64IEEE 754-2008), 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 "R" se nepovede úspěšně převést dvojité přesnosti s plovoucí desetinou čárkou.

Při použití s Single hodnotou specifikátor formátu "G9" zajistí, aby původní Single hodnota byla úspěšně zaokrouhlená. Důvodem je to, že Single jde o jednopřesné číslo kompatibilní s plovoucí desetinou čárkou (binary32IEEE 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 má vliv na formátování aktuálního objektu NumberFormatInfo . Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo 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 hodnoty s plovoucí desetinabídkou s obecným specifikátorem 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 má vliv na formátování aktuálního objektu NumberFormatInfo . Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo 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č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 hodnoty s plovoucí desetinabídkou s 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 percent (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 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.

Vlastnost NumberFormatInfo 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 specifikátorem 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 odezvy (R)

Specifikátor formátu kruhové cesty ("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, , SingleDoublea BigInteger typy.

V rozhraní .NET Framework a ve verzích .NET Core starších než 3.0 se specifikátor formátu R nepodaří v některých případech úspěšně zaokrouhlit 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 naformátovaná 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 má vliv na formátování aktuálního objektu NumberFormatInfo . Následující tabulka uvádí NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.

Vlastnost NumberFormatInfo 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 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 se hodnoty formátované standardním řetězcem číselného formátu R úspěšně nezaokrouhlují, Double 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 formátovaným řetězcem standardního číselného Double formátu R, pokud je zkompilován pomocí /platform:x64 nebo přepínačů, a /platform:anycpu spustit je v 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á se úspěšně nezaokrouhluje, 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žívání standardních řetězců číselného formátu.

nastavení Ovládací panely

Nastavení položky Místní a Jazykové možnosti v Ovládací panely 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) konstruktor slouží k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální systémová jazyková verze, všechny vlastní nastavení vytvořené položkou Místní a Jazykové možnosti v Ovládací panely se použijí na nový CultureInfo objekt. Konstruktor CultureInfo(String, Boolean) můžete použít k vytvoření objektu CultureInfo , který neodráží přizpůsobení 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ě IFormatProvider parametrem metody, která vyvolá formátování. NumberFormatInfo Zadejte parametr nebo CultureInfo objekt.

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é 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, , , UInt16Int64SByteInt16Int32, 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 s plovoucí desetinnou čárkou je kladné nekonečno, záporné nekonečno nebo není číslo (NaN), formátovaný řetězec je hodnota příslušného 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 čí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. Tento příklad používá dva konkrétní číselné typy (Double a Int32), ale by přinesl podobné výsledky pro kterýkoli z ostatních číselných základních typů (Byte, SByte, , , Int16Int32, , UInt32UInt64Int64BigIntegerDecimalUInt16Halfa ).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: {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é