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í číselný formátovací řetězec má formu [format specifier][precision specifier] , kde:

  • Specifikátor formátu je jeden abecední znak, který určuje typ číselného formátu, například Currency nebo Percent. 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í číselné formátovací řetězce.

  • Specifikátor přesnosti je volitelné celé číslo, které má vliv na počet číslic ve výsledném řetězci. V rozhraní .NET 6 a novějších verzích je maximální hodnota přesnosti Int32.MaxValue . V předchozích verzích .NET může být přesnost v rozsahu od 0 do 99. Specifikátor přesnosti určuje počet číslic v řetězcové reprezentaci čísla. Neprovádí zaokrouhlení samotného čísla. K provedení operace zaokrouhlení použijte Math.Ceiling Math.Floor metodu, nebo Math.Round .

    Pokud specifikátor přesnosti řídí počet zlomkových číslic ve výsledném řetězci, výsledný řetězec odráží číslo, které je zaokrouhleno na reprezentovatelné výsledky nejbližší nekonečně přesnému výsledku. Pokud existují dva stejně blízkoně dostupné výsledky:

    • V .NET Framework a .NET Core až do .NET core 2,0 vybírá modul runtime výsledek s větší nejméně významnou číslicí (tj MidpointRounding.AwayFromZero . pomocí).
    • V .NET Core 2,1 a novější modul runtime vybírá výsledek s nejméně významnou číslicí (tj MidpointRounding.ToEven . pomocí).

    Poznámka

    Specifikátor přesnosti určuje počet číslic ve výsledném řetězci. Chcete-li doplnit výsledný řetězec pomocí počátečních nebo koncových mezer, použijte funkci složeného formátování a definujte součást zarovnání v položce formátu.

Standardní řetězce číselného formátu jsou podporovány v:

Tip

Můžete si stáhnout formátovací nástroj, aplikaci .net Core model Windows Forms, která umožňuje použití řetězců formátu na číselné hodnoty nebo hodnoty data a času a zobrazuje 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 vzorový výstup vyprodukovaný každým specifikátorem formátu. Další informace o používání řetězce standardního číselného formátu naleznete v části poznámky a v části příklad kódu pro 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, nastavení uživatele, proměnné prostředí a verze rozhraní .NET, kterou používáte, můžou mít vliv na formát. Například Počínaje rozhraním .NET 5 se .NET pokusí sjednotit kulturní formáty napříč platformami. Další informace najdete v tématu .NET globalizace a ICU.

Specifikátor formátu Název Description 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: 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 desítkového formátu ("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", en-US)
-> 1.052033 E + 003

1052,0329112756 ("e", fr-FR)
-> 1, 052033e + 003

-1052,0329112756 ("E2", en-US)
->-1,05 e + 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: definuje 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, 1234,5600
"G" nebo "g" Obecné Výsledek: kompaktnější rozhraní s pevnou desetinnou čárkou 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.234567890 e-25 ("G", en-US)
->-1.23456789 E-25

-1.234567890 e-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: definuje 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: definuje 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 v: Single , Double a BigInteger .

Poznámka: doporučuje se BigInteger jenom pro 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 Round-Trip ("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á za FormatException běhu v době běhu.

Použití standardního číselného formátovacího řetězce

Poznámka

Příklady C# v tomto článku se spouštějí v Try.NET inline Code Runner a playground. Kliknutím na tlačítko Spustit spustíte příklad v interaktivním okně. Po spuštění kódu ho můžete upravit a spustit upravený kód tak, že znovu vyberete Spustit . Upravený kód buď běží v interaktivním okně, nebo, pokud kompilace není úspěšná, interaktivní okno zobrazí všechny chybové zprávy kompilátoru C#.

Standardní číselný formátovací řetězec 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 TryFormat metodě 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
    
  • Dá se zadat jako formatString argument v položce formátu používané s těmito metodami jako String.Format , Console.WriteLine a 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 zda je jeho hodnota zarovnána vpravo nebo vlevo. Následující příklad Zarovná hodnotu měny v poli se 28 znaky a v poli se 14 znaky Zarovná hodnotu měny.

    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 položce interpolované výrazu interpolované řetězcové položky. Další informace naleznete v článku o interpolaci řetězců v referenci jazyka C# nebo v článku interpolované řetězce v odkazu na Visual Basic.

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 je specifikátor přesnosti vynechán, 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.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny 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 představováno závorkami nebo NegativeSign vlastností.
NegativeSign Definuje záporné znaménko CurrencyNegativePattern , které se používá, pokud označuje, že se nepoužívají kulaté 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 pomocí specifikátoru 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

Desítkový specifikátor formátu (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.

Na výsledný řetězec má vliv informace 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

Exponenciální specifikátor 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.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny 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 pomocí exponenciálního specifikátoru 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 desetinnou čárkou (F)

Specifikátor formátu s pevnou desetinnou čárkou ("F") převede číslo na řetězec ve formátu "-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, aktuální NumberFormatInfo.NumberDecimalDigits vlastnost poskytuje číselnou přesnost.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny vlastnosti NumberFormatInfo objektu, 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 a Int32 hodnotu pomocí specifikátoru formátu s pevnou desetinnou čárkou:

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                        

Obecný specifikátor formátu (G)

Obecný specifikátor formátu ("G") převede číslo na více kompaktních hodnot s pevnou desetinnou čárkou nebo vědeckým zápisem 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 Neomezeno (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 však číslo Decimal a specifikátor přesnosti vynecháno, je vždy použit zápis s pevnou desetinnou čárkou a koncové nuly jsou zachovány.

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" zajišťuje, aby původní Double hodnota úspěšně převedla odezvy. Důvodem je Double , že je číslo s plovoucí desetinnou čárkou () s dvojitou přesností kompatibilní s IEEE 754-2008 binary64 , které poskytuje až 17 platných číslic přesnosti. V .NET Framework doporučujeme použít místo specifikátoru formátu "r", protože v některých případech "r" se nepodaří úspěšně přesměrovat hodnoty s plovoucí desetinnou čárkou v podobě dvojitých přesností na cestu.

Při použití s Single hodnotou specifikátor formátu "G9" zajišťuje, aby původní Single hodnota úspěšně převedla odezvy. Důvodem je Single , že je číslo s plovoucí desetinnou čárkou () s jednoduchou přesností, které je kompatibilní s IEEE 754-2008 binary32 , které poskytuje až devět platných číslic přesnosti. Z důvodů výkonu doporučujeme použít místo specifikátoru formátu "R".

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny 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í desetinnou čá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í.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny 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 představováno závorkami 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í desetinnou čárkou pomocí specifikátoru číselného formátu:

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 
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 

Procentuální specifikátor formátu (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, je použita výchozí číselná přesnost dodaná aktuální PercentDecimalDigits vlastností.

V následující tabulce jsou uvedeny 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í desetinnou čárkou pomocí specifikátoru formátu procenta:

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 Round-Trip (R)

Specifikátor formátu Round-Trip ("R") se pokusí zajistit, že číselná hodnota, která je převedena na řetězec, bude analyzována zpět do stejné číselné hodnoty. Tento formát je podporován pouze pro Half typy, Single , a Double BigInteger .

Pro Double hodnoty specifikátor formátu "R" v některých případech se nepodaří úspěšně odeslat původní hodnotu z cesty. U obou Double Single hodnot i nabízí také poměrně špatný 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 zacyklení Single hodnot.

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

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í. Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu. V následující tabulce jsou uvedeny 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 pomocí specifikátoru formátu Round-Trip.

#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 hodnoty formátované pomocí standardního číselného formátovacího řetězce "R" nemusejí úspěšně odcyklovat cestu, pokud jsou kompilovány pomocí /platform:x64 /platform:anycpu přepínačů nebo a spouštěny v 64 systémech. Další informace najdete v následujícím článku.

Chcete-li se vyhnout problému Double hodnot formátovaných pomocí standardního číselného formátovacího řetězce "R", neúspěšně se zaokrouhlí na Trip, pokud jsou kompilovány pomocí /platform:x64 /platform:anycpu přepínačů nebo a spouštěny v systémech 64. můžete formátovat Double hodnoty pomocí standardního číselného formátovacího řetězce "G17". Následující příklad používá formátovací řetězec "R" s Double hodnotou, která neprovádí operaci round-trip, a také používá řetězec formátu "G17" k úspěšnému přenosu 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

Šestnáctkový specifikátor 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.

Na výsledný řetězec nemá vliv informace o formátování aktuálního NumberFormatInfo objektu.

Následující příklad formátuje Int32 hodnoty pomocí hexadecimálního specifikátoru 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í standardního číselného formátovacího řetězce.

Nastavení ovládacích panelů

Nastavení v položce místní a jazykové nastavení v Ovládacích panelech ovlivní výsledný řetězec vytvořený při operaci formátování. Tato nastavení slouží k inicializaci NumberFormatInfo objektu přidruženého k aktuální jazykové verzi vlákna, které poskytuje hodnoty použité 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) je konstruktor použit k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální jazyková verze systému, všechna přizpůsobení, která jsou vytvořena položkou místní a jazykové nastavení v Ovládacích panelech, budou použita pro nový CultureInfo objekt. Konstruktor můžete použít CultureInfo(String, Boolean) k vytvoření CultureInfo objektu, který nereflektuje vlastní nastavení systému.

Vlastnosti NumberFormatInfo

Formátování je ovlivněno vlastnostmi aktuálního NumberFormatInfo objektu, který je poskytnut implicitně aktuální jazykovou verzí vlákna nebo explicitně IFormatProvider parametrem metody, která vyvolá formátování. Zadejte NumberFormatInfo objekt nebo CultureInfo pro tento parametr.

Poznámka

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

Číselné typy integrálních a plovoucích bodů

Některé popisy specifikátorů standardního číselného formátu odkazují na integrální číselné typy nebo typy s plovoucí desetinnou čárkou. Integrální číselné typy jsou Byte , SByte ,, Int16 Int32 , Int64 , UInt16 , UInt32 , UInt64 a BigInteger . Číselné typy s plovoucí desetinnou čárkou jsou Decimal , Half , Single a Double .

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

Bez ohledu na řetězec formátu, pokud Half je hodnota typu, nebo s Single Double plovoucí desetinnou čárkou kladné nekonečno, záporné nekonečno nebo nečíselné (NaN), formátovaný řetězec je hodnota příslušné PositiveInfinitySymbol vlastnosti, nebo, NegativeInfinitySymbol 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. Tento příklad používá dva konkrétní číselné typy ( Double a Int32 ), ale má za následek podobné výsledky pro libovolný z dalších číselných základních typů ( Byte , SByte , Int16 , Int32 , Int64 , UInt16 , UInt32 , UInt64 , BigInteger , Decimal , Half , a 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é