Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina

Vlastní řetězce číselného formátu

.NET Framework (current version)
 

Lze vytvořit vlastní číselný formátovací řetězec, který se skládá z jednoho nebo několika vlastních číselných specifikátorů pro definování formátování číselných dat. Vlastní číselný formátovací řetězec je formátovací řetězec, který není standardního řetězce formátu čísel.

Vlastní řetězce číselného formátu podporuje někteří přetížení ToString Metoda všechny číselné typy. Například můžete zadat řetězec číselného formátu ToString(String) a ToString(String, IFormatProvider) metody Int32 typu. Vlastní řetězce číselného formátu také podporuje rozhraní .NET Framework funkce složeného formátování, který je využíván jiným některé Write a WriteLine metody Console a StreamWriter třídy, String.Format metody a StringBuilder.AppendFormat Metoda.

System_CAPS_tipTip

Můžete si stáhnout formátování nástroj, aplikace, která umožňuje použití formátu řetězců na numerické nebo datum a čas hodnoty a zobrazuje výsledný řetězec.

Následující tabulka popisuje vlastní specifikátory číselného formátu a zobrazuje ukázkový výstup vyprodukovaný každým specifikátorem formátu. Najdete v článku Poznámky části Další informace o používání vlastní řetězce číselného formátu a Příklad části komplexní ukázky jejich použití.

Specifikátor formátu

Název

Popis

Příklady

"0"

Zástupný symbol nula

Nahradí nulu odpovídající číslicí, pokud je dostupná. V opačném případě se nula zobrazí ve výsledném řetězci.

Další informace: "0" vlastní specifikátor.

1234.5678 ("00000") -> 01235

0.45678 ("0,00" en US) -> 0.46

0.45678 ("0,00", fr-FR) -> 0,46

"#"

Zástupný symbol číslice

Nahradí znak "#" odpovídající číslicí, pokud je k dispozici. V opačném případě se ve výsledném řetězci nezobrazí žádná číslice.

Všimněte si, že se ve výsledném řetězci nezobrazí žádná číslice, je-li odpovídající číslice ve vstupním řetězci není významný 0. Například 0003 ("###") -> 3.

Další informace: "#" vlastní specifikátor.

1234.5678 ("#####") -> 1235

0.45678 ("#. ##", en US) ->.46

0.45678 ("#. ##", fr-FR) -> 46

"."

Desetinná tečka

Určuje umístění oddělovače desetinných míst ve výsledném řetězci.

Další informace: "." Vlastní specifikátor.

0.45678 ("0,00" en US) -> 0.46

0.45678 ("0,00", fr-FR) -> 0,46

","

Oddělovač skupin a číselné měřítko

Slouží jako oddělovač skupin a specifikátor číselného měřítka. Jako oddělovač skupin vloží znak oddělovače skupiny podle jazykové verze mezi jednotlivé skupiny. Jako specifikátor měřítka rozdělí číslo po 1000 pro každou zadanou čárku.

Další informace: "," vlastní specifikátor.

Specifikátor oddělovače skupin:

2147483647 ("##, #", en US) -> 2 147 483 647

2147483647 ("##, #", es-ES) -> 2.147.483.647

Specifikátor měřítka:

2147483647 ("#, #,," en US) -> 2 147

2147483647 ("#, #, es-ES) -> 2.147

"%"

Zástupný znak procent

Vynásobí číslo 100 a vloží do výsledného řetězce symbol procenta podle jazykové verze.

Další informace: "%" vlastní specifikátor.

0.3697 ("% #0.00", en US) -> % 36.97

0.3697 ("% #0.00", el-GR) -> % 36,97

0.3697 ("##.0 %", en US) -> 37.0 %

0.3697 ("##.0 %", el-GR) -> 37,0 %

"‰"

Zástupný symbol promile

Vynásobí číslo 1000 a vloží do výsledného řetězce symbol promile podle jazykové verze.

Další informace: "‰" vlastní specifikátor.

0.03697 ("#0.00‰", en US) -> 36.97‰

0.03697 ("#0.00‰", ru-RU) -> 36, 97‰

"E0"

"E+0"

"E-0"

"e0"

"e+0"

"e-0"

Exponenciální zápis

Pokud následuje alespoň jedna 0 (nula), zformátuje výsledek pomocí exponenciálního zápisu. Velikost písmen "E" nebo "e" označuje velikost symbolu exponentu ve výsledném řetězci. Počet nul následujících znak "E" nebo "e" určuje minimální počet číslic v exponentu. Znaménko plus (+) označuje, že znak znaménka vždy předchází exponent. Znaménko mínus (-) označuje, že znak znaménka předchází pouze u záporných exponentů.

Další informace: "E" a "e" vlastní specifikátory.

987654 ("#0.0e0") -> 98.8e4

1503.92311 1.504e + 03 -> ("0.0 ##e + 00")

1.8901385E-16 ("0.0e + 00") -> 1.9e-16

\

Řídicí znak

Způsobí, že následující znak je interpretován jako literál, nikoli jako specifikátor vlastního formátu.

Další informace: "\" řídicí znak.

987654 ("\###00\#") -> #987654#

"řetězec"

"řetězec"

Oddělovač řetězcového literálu

Označuje, že uzavřené znaky by měly být zkopírovány do výsledného řetězce beze změny.

68 ("#" stupních"") -> 68 stupňů

68 ("#" stupňů. ") -> 68 stupňů

;

Oddělovač oddílů

Definuje oddíly se zvláštními formátovacími řetězci pro kladná, záporná a nulová čísla.

Další informace: ";" Část oddělovače.

12.345 ("#0.0#;(#0.0#);-\0-") -> 12.35

0 ("#0.0#;(#0.0#);-\0-") -> -0-

-12.345 ("#0.0#;(#0.0#);-\0-") -> (12.35)

12.345 ("#0.0#;(#0.0#)") -> 12.35

0 ("#0.0#;(#0.0#)") -> 0.0

-12.345 ("#0.0#;(#0.0#)") -> (12.35)

Ostatní

Všechny ostatní znaky

Znak je zkopírován do výsledného řetězce beze změny.

68 ("# °") -> 68 °

V následujících částech jsou uvedeny podrobné informace o jednotlivých vlastních specifikátorech číselného formátu.

Specifikátor vlastního formátu "0" slouží jako zástupný symbol nuly. Pokud právě formátovaná hodnota má číslici na pozici, kde se zobrazí nula ve formátovacím řetězci, je tato číslice zkopírována do výsledného řetězce. V opačném případě se ve výsledném řetězci zobrazí nula. Pozice nuly nejvíce vlevo od desetinné čárky a nuly nejvíce vpravo od desetinné čárky určuje rozsah číslic, které jsou vždy obsaženy ve výsledném řetězci.

Specifikátor "00" způsobí, že hodnota se zaokrouhlí na nejbližší číslici předcházející desítky, kde je vždy použito zaokrouhlení směrem od nuly. Například formátování 34,5 se specifikátorem "00" dává výslednou hodnotu 35.

Následující příklad zobrazí několik hodnot, které jsou formátovány pomocí vlastních formátovacích řetězců, které obsahují zástupné symboly nuly.

 double value;

 value = 123;
 Console.WriteLine(value.ToString("00000"));
 Console.WriteLine(String.Format("{0:00000}", value));
 // Displays 00123

 value = 1.2;
 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                   "{0:0.00}", value));
 // Displays 1.20

 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:00.00}", value));
 // Displays 01.20

 CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
 Console.WriteLine(value.ToString("00.00", daDK)); 
 Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
 // Displays 01,20

 value = .56;
 Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0.0}", value));
 // Displays 0.6

 value = 1234567890;
 Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0}", value));	
 // Displays 1,234,567,890      

 CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
 Console.WriteLine(value.ToString("0,0", elGR));	
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));	
 // Displays 1.234.567.890

 value = 1234567890.123456;
 Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.0}", value));	
 // Displays 1,234,567,890.1  

 value = 1234.567890;
 Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.00}", value));	
 // Displays 1,234.57 

Zpět na tabulku

Specifikátor vlastního formátu "#" slouží jako zástupný symbol číslice. Pokud právě formátovaná hodnota má číslici na pozici, kde se nachází ve formátovacím řetězci znak "#", zkopíruje se číslice do výsledného řetězce. V opačném případě není na této pozici v řetězci uloženo nic.

Tento specifikátor nikdy nezobrazí nulu, která není platnou číslici, a to ani v případě, že je nula jedinou číslicí v řetězci. Nulu zobrazí pouze v případě, že je podstatnou číslicí v zobrazeném řetězci.

Formátovací řetězec "## "způsobí, že hodnota se zaokrouhlí na nejbližší číslici předcházející desítky, kde je vždy použito zaokrouhlení směrem od nuly. Například formátování 34,5 se specifikátorem "##" dává výslednou hodnotu 35.

Následující příklad zobrazí několik hodnot, které jsou formátovány pomocí vlastních formátovacích řetězců, které obsahují zástupné symboly číslice.

  double value;

  value = 1.2;
  Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#.##}", value));
  // Displays 1.2

  value = 123;
  Console.WriteLine(value.ToString("#####"));
  Console.WriteLine(String.Format("{0:#####}", value));
  // Displays 123

  value = 123456;
  Console.WriteLine(value.ToString("[##-##-##]"));      
  Console.WriteLine(String.Format("{0:[##-##-##]}", value));      
// Displays [12-34-56]

  value = 1234567890;
  Console.WriteLine(value.ToString("#"));
  Console.WriteLine(String.Format("{0:#}", value));
  // Displays 1234567890

  Console.WriteLine(value.ToString("(###) ###-####"));
  Console.WriteLine(String.Format("{0:(###) ###-####}", value));
  // Displays (123) 456-7890

Chcete-li vrátit výsledek řetězec, ve kterém chybí číslic nebo úvodní nuly jsou nahrazovány mezery, použijte funkce složeného formátování a zadejte šířku pole, jak ukazuje následující příklad.

using System;

public class Example
{
   public static void Main()
   {
      Double value = .324;
      Console.WriteLine("The value is: '{0,5:#.###}'", value);
   }
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'

Zpět na tabulku

Specifikátor vlastního formátu "." vloží lokalizovaný oddělovač desetinných míst do výsledného řetězce. První tečka ve formátovacím řetězci určuje umístění oddělovače desetinných míst ve formátované hodnotě. Jakékoli další tečky jsou ignorovány.

Znak, který se používá jako oddělovač desetinných míst ve výsledném řetězci není vždy dobou; je dáno NumberDecimalSeparator vlastnost NumberFormatInfo objekt, který řídí formátování.

Následující příklad používá specifikátor formátu "." pro určení umístění desetinné tečky v několika výsledných řetězcích.

  double value;

  value = 1.2;
  Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:0.00}", value));
  // Displays 1.20

  Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:00.00}", value));
  // Displays 01.20

  Console.WriteLine(value.ToString("00.00", 
                    CultureInfo.CreateSpecificCulture("da-DK")));
  Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                    "{0:00.00}", value));
  // Displays 01,20

  value = .086;
  Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)); 
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#0.##%}", value)); 
  // Displays 8.6%

  value = 86000;
  Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                    "{0:0.###E+0}", value));
// Displays 8.6E+4

Zpět na tabulku

Znak "," slouží jako oddělovač skupin a specifikátor číselného měřítka.

  • Oddělovač skupin: Pokud je zadána jedna nebo více čárek mezi dva zástupné znaky pro číslice (0 nebo #), které formátují integrální číslice čísla, je znak oddělovače skupin vložen mezi každou číselnou skupinu do integrální části výstupu.

    NumberGroupSeparator a NumberGroupSizes vlastnosti aktuální NumberFormatInfo objekt určí znak použitý jako oddělovač číselných skupin a velikost každé skupiny čísel. Pokud je například pro formátování čísla 1000 použit řetězec "#,#" a invariantní jazyková verze, zobrazí se výstup "1,000".

  • Specifikátor číselného měřítka: Pokud je zadána jedna nebo více čárek bezprostředně vlevo od explicitní nebo implicitní desetinné tečky, pak číslo, které má být formátováno, je vyděleno hodnotou 1000 pro každou tečku. Pokud je pro formátování čísla 100 milionů použit například řetězec "0,," , je výsledná hodnota "100".

Můžete použít oddělovač skupin a specifikátory číselného měřítka ve stejném formátovacím řetězci. Pokud je pro formátování čísla jedna miliarda použit například řetězec "#,0,," a invariantní jazyková verze, zobrazí se výstup "1,000".

Následující příklad ukazuje použití čárky jako oddělovače skupin.

double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,#}", value));
// Displays 1,234,567,890      

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,##0,,}", value));
// Displays 1,235      	

Následující příklad ukazuje použití čárky jako specifikátoru číselného měřítka.

   double value = 1234567890;
   Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));	
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,}", value));	
   // Displays 1235   

   Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,,}", value));
// Displays 1  

   Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));       
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,##0,,}", value));       
// Displays 1,235

Zpět na tabulku

Znak procent (%) ve formátovacím řetězci způsobí, že číslo bude vynásobené hodnotou 100 dříve, než je formátováno. Lokalizovaný symbol procenta je vložen do čísla na místo, kde se % vyskytuje ve formátovacím řetězci. Použít znak procenta je definována PercentSymbol Vlastnost aktuálního NumberFormatInfo objektu.

Následující příklad definuje několik vlastních formátovacích řetězců, které obsahují vlastní specifikátor "%".

double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#0.##%}", value));
// Displays 8.6%      

Zpět na tabulku

Znak promile (‰ nebo \u2030) ve formátovacím řetězci způsobí, že číslo se vynásobí hodnotou 1000 dříve, než je formátováno. Příslušný symbol promile je vložen do vráceného řetězce na místě, kde se zobrazí symbol ‰ ve formátovacím řetězci. Promile znak použitý definované NumberFormatInfo.PerMilleSymbol vlastnost objektu, který poskytuje informace o formátování specifické pro jazykovou verzi.

Následující příklad definuje vlastní formátovací řetězec, který obsahuje vlastní specifikátor "‰".

double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰      

Zpět na tabulku

Pokud je ve formátovacím řetězci přítomný některý z řetězců "E", "E+", "E-", "e", "e+" nebo "e-" a je okamžitě následován alespoň jednou nulou, je číslo formátováno pomocí vědeckého zápisu se znakem "E" nebo "e" vloženým mezi číslo a exponent. Počet nul následujících po indikátoru vědeckého zápisu určuje minimální počet číslic pro výstup exponentu. Formáty "E+" a "e+" označují, že znaménka plus nebo minus by měla vždy předcházet exponent. Formáty "E", "E-", "e" nebo "e-" označují, že znak znaménka by měl předcházet pouze záporné exponenty.

Následující příklad formátuje několik číselných hodnot pomocí specifikátorů pro vědecký zápis.

double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E-000}", value));
// Displays 8.6E004

Zpět na tabulku

Symboly "#", "0", ".", ",", "%" a "‰" jsou ve formátovacím řetězci interpretovány jako specifikátory formátu, nikoli jako literální znaky. V závislosti na jejich umístění ve vlastním formátovacím řetězci lze velké a malé písmeno "E" a také symboly + a - interpretovat jako specifikátory formátu.

Chcete-li zamezit interpretaci znaku jako specifikátoru formátu, lze před znak vložit zpětné lomítko (\), což je řídicí znak. Řídicí znak označuje, že následující znak je literální znak, který má být zahrnut do výsledného řetězce beze změny.

Pro vložení zpětného lomítka do výsledného řetězce, musíte před něj vložit další zpětné lomítko (\\).

System_CAPS_notePoznámka

Některé kompilátory, jako je například kompilátory jazyka C++ a C#, mohou také interpretovat jedno zpětné lomítko jako řídicí znak. Chcete-li zajistit, že řetězec je interpretován při formátování správně, můžete použít literální řetězcový znak verbatim (znak @) před řetězcem v jazyce C#, nebo přidejte další znak zpětného lomítka před každé zpětné lomítko v jazyce C# a C++. Následující příklad jazyka C# ukazuje oba přístupy.

Následující příklad používá řídicí znak, aby zabránil formátovacím operacím v interpretaci znaků "#", "0" a "\" jako specifikátorů formátu nebo řídicích znaků. Příklady jazyka C# používají další zpětné lomítko k tomu, aby zpětné lomítko bylo interpretováno jako literální znak.

int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Zpět na tabulku

Středník (;) je podmíněný specifikátor formátu, který aplikuje odlišné formátování pro číslo v závislosti na tom, zda je jeho hodnota kladná, záporná nebo nulová. Pro vytvoření takového typu formátování může vlastní formátovací řetězec obsahovat až tři oddíly oddělené středníky. Tyto oddíly jsou popsány v následující tabulce.

Počet oddílů

Popis

Jeden oddíl

Formátovací řetězec se vztahuje na všechny hodnoty.

Dva oddíly

První oddíl je aplikován na kladné a nulové hodnoty a druhý oddíl je aplikován na záporné hodnoty.

Pokud číslo, které má být formátováno, je záporné, ale bude po zaokrouhlení podle formátu ve druhém oddílu rovno nule, bude výsledná nula formátována podle prvního oddílu.

Tři oddíly

První oddíl se používá pro kladná čísla, druhý oddíl pro záporné hodnoty a třetí oddíl pro nulové hodnoty.

Druhá část může být ponechána prázdná (tím, že mezi středníky nic nebude). V tomto případě se první část vztahuje na všechny nenulové hodnoty.

Pokud číslo, které má být formátováno, je nenulové, ale bude po zaokrouhlení podle formátu v prvním nebo druhém oddílu rovno nule, výsledná nula bude formátována podle třetího oddílu.

Oddělovače oddílů ignorují všechna dříve existující formátování přidružená k číslu, pokud je na formátována konečná hodnota. Například záporné hodnoty se při použití oddělovače oddílu zobrazí vždy bez znaménka mínus. Pokud chcete, aby konečná formátovaná hodnota měla symbol mínus, měli byste explicitně zahrnout symbol mínus jako část specifikátoru vlastního formátu.

Následující příklad používá specifikátor formátu ";" pro formátování kladných, záporných a nulových čísel odlišným způsobem.

double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";

Console.WriteLine(posValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));    
// Displays 1234

Console.WriteLine(negValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));    
// Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3)); 
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**

Zpět na tabulku

Bez ohledu na řetězec formátu Pokud hodnota Single nebo Double s plovoucí desetinnou čárkou typ je kladné nekonečno, záporné nekonečno nebo nečíselné (NaN), formátovaný řetězec je hodnotou příslušné PositiveInfinitySymbol, NegativeInfinitySymbol, nebo NaNSymbol vlastnost určeného aktuálně používán NumberFormatInfo objektu.

Nastavení v místní a jazykové nastavení položku Ovládací panely ovlivní výsledný řetězec vytvořený při operaci formátování. Tato nastavení slouží k chybě při inicializaci NumberFormatInfo objekt přidružený jazykové verze aktuálního vlákna, a poskytuje hodnoty použité k řízení formátování jazykové verze aktuálního vlákna. Počítače, které používají různá nastavení generují různé výsledné řetězce.

Kromě toho, pokud použijete CultureInfo.CultureInfo(String) konstruktor k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální jazykovou verzi systému, jakékoli vlastní nastavení místní a jazykové nastavení v Ovládacích panelech budou použita pro nový CultureInfo objektu. Můžete použít CultureInfo.CultureInfo(String, Boolean) konstruktor k vytvoření CultureInfo objekt, který nepředstavuje vlastní nastavení systému.

Pro formátovací řetězce s pevnou desetinnou čárkou (což jsou formátovací řetězce, které neobsahují vědecké formátovací znaky) jsou čísla zaokrouhlena na tolik desetinných míst, kolik je zástupných symbolů číslic napravo od desetinné čárky. Pokud formátovací řetězec neobsahuje desetinnou čárku, bude číslo zaokrouhleno na nejbližší celé číslo. Pokud má dané číslo více číslic, než je počet zástupných symbolů číslic nalevo od desetinné čárky, jsou další číslice zkopírovány do výsledného řetězce bezprostředně před první zástupný symbol číslice.

Zpět na tabulku

Následující příklad ukazuje dva vlastní číselné formátovací řetězce. V obou případech zástupný symbol číslice (#) zobrazí číselná data a všechny ostatní znaky jsou zkopírovány do výsledný řetězec.

double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);

int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42

Zpět na tabulku

Zobrazit: