Standard numerikus formátumú sztringek

  • Cikk

A standard numerikus formátumú sztringek a gyakori numerikus típusok formázására szolgálnak. A standard numerikus formátumú sztring a következő formában [format specifier][precision specifier]jelenik meg:

  • A Formátumválasztó egy betűrendes karakter, amely megadja a számformátum típusát, például pénznemet vagy százalékot. Minden olyan numerikus formázási sztring, amely egynél több betűrendes karaktert tartalmaz, beleértve a szóközt is, egyéni numerikus formázási sztringként lesz értelmezve. További információ: Egyéni numerikus formátumú sztringek.

  • A pontosság-meghatározó egy nem kötelező egész szám, amely befolyásolja az eredményül kapott sztring számjegyeinek számát. A .NET 7 és újabb verzióiban a maximális pontossági érték 999 999 999. A .NET 6-ban a maximális pontossági érték a .Int32.MaxValue A korábbi .NET-verziókban a pontosság 0 és 99 között lehet. A pontosság-meghatározó egy szám sztringképében szereplő számjegyek számát szabályozza. Maga a szám nem kerekül. Kerekítési művelet végrehajtásához használja a , Math.Floora vagy Math.Round a Math.Ceilingmetódust.

    Amikor a pontosság-meghatározó az eredménysztringben a tört számjegyek számát vezérli, az eredménysztring egy, a végtelenül pontos eredményhez legközelebbi, megjeleníthető eredményre kerekített számot tükröz. Ha két hasonlóan közel ábrázolható eredmény van:

    • A .NET-keretrendszer és a .NET Core esetén a .NET Core 2.0-ig a futtatókörnyezet az eredményt a legkisebb jelentős számjegygel (azaz a használatávalMidpointRounding.AwayFromZero) választja ki.
    • A .NET Core 2.1-ben és újabb verzióiban a futtatókörnyezet egy még ennél is legkisebb számjegyű (azaz a használatával) MidpointRounding.ToEvenválasztja ki az eredményt.

    Megjegyzés

    A pontosság-meghatározó határozza meg a számjegyek számát az eredménysztringben. Ha kezdő vagy záró szóközöket tartalmazó eredménysztringet szeretne beszúrni, használja az összetett formázási funkciót, és definiáljon egy igazítási összetevőt a formátumelemben.

A standard numerikus formátumú sztringeket a következők támogatják:

Tipp

Letöltheti a Formatting Segédprogramot, egy .NET Core Windows Forms alkalmazást, amellyel formázó sztringeket alkalmazhat numerikus vagy dátum- és időértékekre, és megjelenítheti az eredménysztringet. A forráskód a C# és a Visual Basic esetében érhető el.

Szabványos formátumkijelölők

Az alábbi táblázat ismerteti a szabványos numerikus formátumkijelölőket, és megjeleníti az egyes formátumkiadók által előállított mintakimenetet. A standard numerikus formátumú sztringek használatával kapcsolatos további információkért tekintse meg a Jegyzetek szakaszt, és a Példakód szakaszt a használatuk átfogó szemléltetéséhez.

Egy adott kultúra formázott sztringjének eredménye eltérhet az alábbi példáktól. Az operációs rendszer beállításai, a felhasználói beállítások, a környezeti változók és a használt .NET-verzió mind hatással lehetnek a formátumra. A .NET 5-tel kezdődően például a .NET megpróbálja egyesíteni a kulturális formátumokat a különböző platformokon. További információ: .NET-globalizáció és intenzív osztály.

Formátumkijelölő Név Leírás Példák
"B" vagy "b" Bináris Eredmény: Bináris sztring.

Támogatott: Csak integráltípusok (.NET 8+).

Pontosság-meghatározó: Az eredménysztringben lévő számjegyek száma.

További információ: A bináris ("B") formátumkijelölő.		 42 ("B")
-> 101010

255 ("b16")
-> 0000000011111111
"C" vagy "c" Pénznem Eredmény: Pénznemérték.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: Tizedesjegyek száma.

Alapértelmezett pontosság-kijelölő: A definíciója: NumberFormatInfo.CurrencyDecimalDigits.

További információ: A pénznem ("C") formátumkijelölője.		 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" vagy "d" Tizedesjegy Eredmény: Egész szám számjegyek opcionális negatív előjellel.

Támogatott: Csak az integráltípusok.

Pontosság-meghatározó: Számjegyek minimális száma.

Alapértelmezett pontosságkijelölő: A szükséges számjegyek minimális száma.

További információ: A Decimális("D") formátumkijelölő.		 1234 ("D")
-> 1234

-1234 ("D6")
- -> 001234
"E" vagy "e" Exponenciális (tudományos) Eredmény: Exponenciális jelölés.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: Tizedesjegyek száma.

Alapértelmezett pontosság-meghatározó: 6.

További információ: Az exponenciális ("E") formátumkijelölő.		 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" vagy "f" Rögzített pont Eredmény: Integrál és decimális számjegyek opcionális negatív előjellel.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: Tizedesjegyek száma.

Alapértelmezett pontosság-kijelölő: A definíciója: NumberFormatInfo.NumberDecimalDigits.

További információ: A Fixed-Point ("F") formátumkijelölő.		 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" vagy "g" Általános kérdések Eredmény: A rögzített pont vagy a tudományos jelölés tömörebb.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: Jelentős számjegyek száma.

Alapértelmezett pontosságkijelölő: A numerikus típustól függ.

További információ: Az Általános ("G") formátumkijelölő.		 -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" vagy "n" Szám Eredmény: Integrál és decimális számjegyek, csoportelválasztók és választható negatív előjellel rendelkező decimális elválasztó.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: A tizedesjegyek kívánt száma.

Alapértelmezett pontosság-kijelölő: A definíciója: NumberFormatInfo.NumberDecimalDigits.

További információ: A numerikus ("N") formátumkijelölő.		 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" vagy "p" Százalék Eredmény: A szám megszorozva 100-zal, és százalékjellel jelenik meg.

Támogatott: Minden numerikus típus.

Pontosság-meghatározó: A tizedesjegyek kívánt száma.

Alapértelmezett pontosság-kijelölő: A definíciója: NumberFormatInfo.PercentDecimalDigits.

További információ: A százalék ("P") formátumkijelölő.		 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" vagy "r" Oda Eredmény: Egy sztring, amely képes azonos számra kerekíteni.

Támogatja: Single, Double, és BigInteger.

Megjegyzés: Csak a BigInteger típushoz ajánlott. A típusok esetében Double használja a "G17" értéket, a típusoknál Single pedig a "G9" értéket.
Pontosság-meghatározó: Figyelmen kívül hagyva.

További információ: Az oda-vissza ("R") formátumkijelölő.		 123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
- -> 1234567890.1234567
"X" vagy "x" Hexadecimális Eredmény: Hexadecimális sztring.

Támogatott: Csak az integráltípusok.

Pontosság-meghatározó: Az eredménysztringben lévő számjegyek száma.

További információ: A Hexadecimális ("X") formátumkijelölő.		 255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Bármely más önálló karakter Ismeretlen kijelölő Eredmény: Futtatáskor a-t FormatException dob.

Standard numerikus formátumú sztringek használata

Megjegyzés

A cikkben szereplő C#-példák a Try.NET beágyazott kódfuttatóban és -játszótéren futnak. Kattintson a Futtatás gombra egy példa interaktív ablakban való futtatásához. Miután végrehajtotta a kódot, módosíthatja és futtathatja a módosított kódot a Futtatás gombra kattintva. A módosított kód vagy az interaktív ablakban fut, vagy ha a fordítás sikertelen, az interaktív ablak megjeleníti az összes C#-fordító hibaüzenetet.

Egy standard numerikus formátumú sztring a numerikus értékek formázásának meghatározására az alábbi módok egyikével határozható meg:

  • Átadható a TryFormat metódusnak vagy a ToString paraméterrel rendelkező format metódus túlterhelésének. Az alábbi példa pénznemsztringként formáz egy numerikus értéket az aktuális kultúrában (ebben az esetben az en-US kultúrában).

    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

  • Argumentumként megadható az formatString olyan metódusokkal használt formátumelemben, mint String.Formata , Console.WriteLine, és StringBuilder.AppendFormat. További információ: Összetett formázás. Az alábbi példa egy formátumelem használatával szúr be egy pénznemértéket egy sztringbe.

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

    Megadhat egy alignment argumentumot, amely megadja a numerikus mező szélességét, valamint azt, hogy az értéke jobbra vagy balra van-e igazítva. Az alábbi példa balra igazít egy pénznemértéket egy 28 karakteres mezőben, és jobbra igazít egy pénznemértéket egy 14 karakteres mezőben.

    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

  • Argumentumként formatString megadható egy interpolált sztring interpolált kifejezéselemében. További információ: A sztring interpolációja című cikk a C# referenciában, vagy az Interpolált sztringek című cikk a Visual Basic referenciában.

Az alábbi szakaszok részletes információkat nyújtanak a standard numerikus formátumú sztringekről.

Bináris formátumkijelölő (B)

A bináris ("B") formátumkijelölő egy számot bináris számjegyek sztringjéhez konvertál. Ez a formátum csak az integráltípusok esetében támogatott, és csak a .NET 8+-on.

A pontosság-meghatározó az eredményül kapott sztringben kívánt számjegyek minimális számát jelzi. Ha szükséges, a szám bal oldalán nullákkal van kitöltve a pontosság-meghatározó által megadott számjegyek számának előállítása érdekében.

Az eredménysztringre az aktuális NumberFormatInfo objektum formázási információi nem lesznek hatással.

Pénznemformátum-meghatározó (C)

A "C" (vagy pénznem) formátumkijelölő egy számot pénznemösszeget képviselő sztringgé alakít át. A pontosság-meghatározó az eredménysztringben a tizedesjegyek kívánt számát jelzi. Ha a pontosság-meghatározó nincs megadva, az alapértelmezett pontosságot a NumberFormatInfo.CurrencyDecimalDigits tulajdonság határozza meg.

Ha a formázandó érték több, mint a tizedesjegyek megadott vagy alapértelmezett száma, a törtérték kerekítése az eredménysztringben történik. Ha a megadott tizedesjegyek számától jobbra lévő érték 5 vagy nagyobb, az eredménysztring utolsó számjegye nullától távol lesz kerekítve.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. Az alábbi táblázat a NumberFormatInfo visszaadott sztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
CurrencyPositivePattern Meghatározza a pozitív értékek pénznemszimbólumának elhelyezését.
CurrencyNegativePattern Meghatározza a negatív értékek pénznemszimbólumának elhelyezését, és megadja, hogy a negatív előjelet zárójelek vagy tulajdonság NegativeSign jelöli-e.
NegativeSign Meghatározza a használt negatív előjelet, ha CurrencyNegativePattern azt jelzi, hogy a rendszer nem használ zárójeleket.
CurrencySymbol Meghatározza a pénznemszimbólumot.
CurrencyDecimalDigits A tizedesjegyek alapértelmezett számát határozza meg egy pénznemértékben. Ezt az értéket a pontosság-meghatározóval felül lehet bírálni.
CurrencyDecimalSeparator Meghatározza a sztringet, amely elválasztja az integrál és a tizedesjegyeket.
CurrencyGroupSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számok csoportjait.
CurrencyGroupSizes A csoportban megjelenő egész számok számát határozza meg.

Az alábbi példa egy Double értéket formáz a pénznemformátum-kijelölővel:

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

Decimális formátumkijelölő (D)

A "D" (vagy decimális) formátum-jelölő egy számot decimális számjegyek (0-9) sztringjéből álló sztringgé alakít át, amelyet mínuszjel előtaggal előtaggal jelöl meg, ha a szám negatív. Ez a formátum csak az integráltípusok esetében támogatott.

A pontosság-meghatározó az eredményül kapott sztringben kívánt számjegyek minimális számát jelzi. Ha szükséges, a szám bal oldalán nullákkal van kitöltve a pontosság-meghatározó által megadott számjegyek számának előállítása érdekében. Ha nincs megadva pontosság-meghatározó, az alapértelmezett érték az egész szám kezdő nullák nélküli megjelenítéséhez szükséges minimális érték.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. Ahogy az alábbi táblázat is mutatja, egyetlen tulajdonság befolyásolja az eredménysztring formázását.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.

Az alábbi példa a Int32 decimális formátumot meghatározó értéket formázza.

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ális formátumkijelölő (E)

Az exponenciális ("E") formátumkijelölő egy számot a "-d.ddd... E+ddd" vagy "-d.ddd... e+ddd", ahol minden "d" számjegyet (0-9) jelez. A sztring mínuszjellel kezdődik, ha a szám negatív. Pontosan egy számjegy mindig megelőzi a tizedesvesszőt.

A pontosság-meghatározó a tizedesvessző utáni számjegyek kívánt számát jelzi. Ha a pontosság-jelölő nincs megadva, a függvény a tizedesvesszőt követő hat számjegyből álló alapértelmezett értéket használja.

A formátumkijelölő esete azt jelzi, hogy a kitevőt "E" vagy "e" előtaggal kell-e előtaggal előtaggal előtagként megadni. A kitevő mindig pluszjelből vagy mínuszjelből és legalább három számjegyből áll. A kitevő nullákkal van kipárnázott állapotban, hogy szükség esetén megfeleljen ennek a minimális értéknek.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. Az alábbi táblázat a NumberFormatInfo visszaadott sztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív az együtthatóra és a kitevőre is.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számjegyet az együttható tizedesjegyeitől.
PositiveSign Meghatározza azt a sztringet, amely azt jelzi, hogy a kitevő pozitív.

Az alábbi példa az Double exponenciális formátumkijelölővel formázza az értéket:

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

Rögzítettpontos formátumkijelölő (F)

A rögzített pont ("F") formátumkijelölő egy számot a "-ddd.ddd..." űrlap sztringjére konvertál. ahol minden "d" számjegyet jelez (0-9). A sztring mínuszjellel kezdődik, ha a szám negatív.

A pontosság-meghatározó a tizedesjegyek kívánt számát jelzi. Ha a pontosság-jelölő hiányzik, az aktuális NumberFormatInfo.NumberDecimalDigits tulajdonság adja meg a numerikus pontosságot.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. Az alábbi táblázat az eredménysztring formázását NumberFormatInfo vezérlő objektum tulajdonságait sorolja fel.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számjegyeket a tizedesjegyektől.
NumberDecimalDigits Meghatározza a tizedesjegyek alapértelmezett számát. Ezt az értéket a pontosság-meghatározóval felül lehet bírálni.

Az alábbi példa egy Double és egy Int32 értéket formáz a rögzítettpontos formátumkijelölővel:

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

Általános formátumkijelölő (G)

Az általános ("G") formátumkijelölő a szám típusától és attól függően, hogy létezik-e pontosság-meghatározó, a rögzített pont vagy a tudományos jelölés tömörebb formátumává konvertálja a számot. A pontosság-meghatározó határozza meg az eredménysztringben megjeleníthető jelentős számjegyek maximális számát. Ha a pontosság-meghatározó hiányzik vagy nulla, a szám típusa határozza meg az alapértelmezett pontosságot az alábbi táblázatban leírtak szerint.

Numerikus típus Alapértelmezett pontosság
Byte vagy SByte 3 számjegy
Int16 vagy UInt16 5 számjegy
Int32 vagy UInt32 10 számjegy
Int64 19 számjegy
UInt64 20 számjegy
BigInteger Korlátlan (ugyanaz, mint az "R")
Half A számjegyek legkisebb ciklikusan három számjegyből álló száma, amely a számot jelöli
Single A számot jelképezendő számjegyek legkisebb ciklikus száma (a .NET-keretrendszer a G7 az alapértelmezett)
Double A számot jelképezendő számjegyek legkisebb kerek száma (a .NET-keretrendszer a G15 az alapértelmezett)
Decimal A számjegyek legkisebb ciklikusan három számjegyből álló száma, amely a számot jelöli

Rögzítettpontos jelölést akkor használ a rendszer, ha a tudományos jelölésben a szám kifejezéséből eredő kitevő -5-nél nagyobb és kisebb, mint a pontosság-megadó; egyéb esetben tudományos jelölést használnak. Az eredmény tartalmaz egy tizedesvesszőt, ha szükséges, és a záró nullákat a tizedesvessző kihagyása után. Ha a pontosság-meghatározó jelen van, és az eredményben szereplő jelentős számjegyek száma meghaladja a megadott pontosságot, a felesleges záró számjegyek kerekítéssel törlődnek.

Ha azonban a szám egy Decimal , és a pontosság-megjelölő nincs megadva, a rendszer mindig rögzített pont jelölést használ, és megőrzi a záró nullákat.

Tudományos jelölés használata esetén az eredmény kitevője "E" előtaggal lesz előtaggal ellátva, ha a formátumjelölő "G", vagy "e", ha a formátumjelölő "g". A kitevő legalább két számjegyet tartalmaz. Ez eltér a tudományos jelölés formátumától, amelyet az exponenciális formátumjelölő állít elő, amely legalább három számjegyet tartalmaz a kitevőben.

Érték használata Double esetén a "G17" formátumjelölő biztosítja, hogy az eredeti Double érték sikeresen átforduljon. Ennek az az oka Double , hogy egy IEEE 754-2008 szabványnak megfelelő dupla pontosságú (binary64) lebegőpontos szám, amely akár 17 jelentős pontosságú számjegyet ad meg. A .NET-keretrendszer az "R" formátumjelölő helyett javasoljuk annak használatát, mivel bizonyos esetekben az "R" nem tud sikeresen oda-vissza kétpontos lebegőpontos értékeket kerekíteni.

Ha értékekkel Single használja, a "G9" formátumjelölő biztosítja, hogy az eredeti Single érték sikeresen átforduljon. Ennek az az oka Single , hogy egy IEEE 754-2008 szabványnak megfelelő egypontos lebegőpontosbinary32 szám, amely akár kilenc jelentős pontosságú számjegyet ad meg. Teljesítménybeli okokból javasoljuk, hogy az "R" formátumkijelölő helyett használja.

Az eredménysztringre hatással van az aktuális NumberFormatInfo objektum formázási információi. Az alábbi táblázat az NumberFormatInfo eredménysztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számjegyeket a tizedesjegyektől.
PositiveSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy kitevő pozitív.

Az alábbi példa a válogatott lebegőpontos értékeket az általános formátumkijelölővel formázza:

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

Numerikus formátumkijelölő (N)

A numerikus ("N") formátumkijelölő a számot "-d,ddd,ddd,ddd.ddd..." formátumú sztringgé alakítja, ahol a "-" szükség esetén negatív számszimbólumot, a "d" egy számjegyet (0-9), a "", a csoportelválasztót, a "." pedig tizedesjelet jelöl. A pontosság-meghatározó a tizedesvessző utáni számjegyek kívánt számát jelzi. Ha a pontosság-megjelölő nincs megadva, a tizedesjegyek számát az aktuális NumberFormatInfo.NumberDecimalDigits tulajdonság határozza meg.

Az eredménysztringre hatással van az aktuális NumberFormatInfo objektum formázási információi. Az alábbi táblázat az NumberFormatInfo eredménysztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.
NumberNegativePattern Meghatározza a negatív értékek formátumát, és megadja, hogy a negatív előjelet zárójelek vagy tulajdonság NegativeSign jelölik-e.
NumberGroupSizes Meghatározza a csoportelválasztók között megjelenő számjegyek számát.
NumberGroupSeparator Meghatározza azt a sztringet, amely elválasztja az egész számok csoportjait.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál és a tizedesjegyeket.
NumberDecimalDigits A tizedesjegyek alapértelmezett számát határozza meg. Ez az érték egy pontosság-megadóval bírálható felül.

Az alábbi példa a számformátum-kijelölővel formázza a válogatott lebegőpontos értékeket:

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

Százalékformátum-kijelölő (P)

A százalék ("P") formátumválasztó megszorozza a számot 100-tal, és százalékértéknek tetsző sztringgé alakítja. A pontosság-megjelölő a tizedesjegyek kívánt számát jelzi. Ha a pontosság-megjelölő nincs megadva, a rendszer az aktuális PercentDecimalDigits tulajdonság által megadott alapértelmezett numerikus pontosságot használja.

Az alábbi táblázat azokat a NumberFormatInfo tulajdonságokat sorolja fel, amelyek a visszaadott sztring formázását szabályozzák.

NumberFormatInfo tulajdonság Leírás
PercentPositivePattern A pozitív értékek százalékszimbólumának elhelyezését határozza meg.
PercentNegativePattern Meghatározza a százalékszimbólum és a negatív értékek negatív szimbólumának elhelyezését.
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.
PercentSymbol Meghatározza a százalékszimbólumot.
PercentDecimalDigits A tizedesjegyek alapértelmezett számát határozza meg százalékértékben. Ezt az értéket felül lehet bírálni a pontosság-meghatározó használatával.
PercentDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál és a tizedesjegyeket.
PercentGroupSeparator Meghatározza azt a sztringet, amely elválasztja az egész számok csoportjait.
PercentGroupSizes A csoportban megjelenő egész számok számát határozza meg.

Az alábbi példa a lebegőpontos értékeket a százalékformátum-kijelölővel formázza:

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 %

Körúti formátumkijelölő (R)

A körúti ("R") formátumkijelölő megpróbálja biztosítani, hogy a sztringgé konvertált numerikus értékeket a rendszer ugyanabba a numerikus értékbe elemezhesse vissza. Ez a formátum csak a , Singlea , Doublea és BigInteger a Halftípus esetében támogatott.

A .NET-keretrendszer és a .NET Core 3.0-snál korábbi verzióiban az "R" formátumjelölő bizonyos esetekben nem tud sikeresen kerekíteni Double az értékeket. Az "R" formátumkijelölő mindkét Double és Single érték esetében viszonylag gyenge teljesítményt nyújt. Ehelyett azt javasoljuk, hogy a "G17" formátumkijelölőt használja az értékekhez Double , a "G9" formátumkijelölőt pedig a sikeres oda-vissza adatváltáshoz Single .

Ha egy BigInteger érték ezzel a kijelölővel van formázva, a sztringábrázolás az érték összes jelentős számjegyét BigInteger tartalmazza.

Bár megadhat egy pontosság-meghatározót, a függvény figyelmen kívül hagyja. A kerek utak elsőbbséget élveznek a pontosságtal szemben, amikor ezt a kijelölőt használják. Az eredménysztringre hatással van az aktuális NumberFormatInfo objektum formázási információi. Az alábbi táblázat az NumberFormatInfo eredménysztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
NegativeSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy szám negatív.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számjegyeket a tizedesjegyektől.
PositiveSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy kitevő pozitív.

Az alábbi példa egy BigInteger értéket formáz az oda-vissza formátumkijelölővel.

#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

Fontos

Bizonyos esetekben Double az "R" standard numerikus formátumú sztringgel formázott értékek nem haladnak végig, ha az /platform:x64 vagy /platform:anycpu kapcsolókkal vannak lefordítva, és 64 bites rendszereken futnak. További információért tekintse meg a következő bekezdést.

Az "R" standard numerikus formázási sztringgel formázott értékek problémájának Double megoldásához, ha a vagy /platform:anycpu kapcsolókkal lefordítva /platform:x64 és 64 bites rendszereken futtatva nem sikerül kerekíteni az értékeket, formázhatja Double az értékeket a "G17" standard numerikus formátumsztring használatával. Az alábbi példa az "R" formátumú sztringet használja olyan Double értékkel, amely nem jár sikerrel, és a "G17" formátumsztringet is használja az eredeti érték sikeres kerekítéséhez:

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

Hexadecimális formátumkijelölő (X)

A hexadecimális ("X") formátumkijelölő hexadecimális számjegyek sztringjé alakítja a számot. A formátumjelölő esete azt jelzi, hogy a 9-nél nagyobb hexadecimális számjegyekhez nagybetűket vagy kisbetűket kell-e használni. Például használja az "X" kifejezést az "ABCDEF" előállításához, az "x" pedig az "abcdef" előállításához. Ez a formátum csak az integráltípusok esetében támogatott.

A pontosság-megjelölő az eredményül kapott sztringben használni kívánt számjegyek minimális számát jelzi. Ha szükséges, a szám nullákkal van kitöltve a bal oldalán, hogy a pontosság-meghatározó által megadott számjegyek számát adja meg.

Az eredménysztringre nincs hatással az aktuális NumberFormatInfo objektum formázási információi.

Az alábbi példa hexadecimális formátumkijelölővel formázza Int32 az értékeket.

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

Jegyzetek

Ez a szakasz további információkat tartalmaz a standard numerikus formátumú sztringek használatáról.

Vezérlőpult beállítások

A Területi és nyelvi beállítások elem beállításai Vezérlőpult befolyásolják a formázási művelet által létrehozott eredménysztringet. Ezekkel a beállításokkal inicializálható az NumberFormatInfo aktuális kulturális környezethez társított objektum, amely a formázás szabályozására szolgáló értékeket biztosít. A különböző beállításokat használó számítógépek különböző eredménysztringeket hoznak létre.

Emellett ha a CultureInfo(String) konstruktor egy olyan új CultureInfo objektum példányosítására szolgál, amely az aktuális rendszerkultúra kulturális környezetével azonos, a területi és nyelvi beállítások elem által az Vezérlőpult által létrehozott testreszabások az új CultureInfo objektumra lesznek alkalmazva. A konstruktor használatával CultureInfo(String, Boolean) olyan objektumot CultureInfo hozhat létre, amely nem tükrözi a rendszer testreszabásait.

NumberFormatInfo tulajdonságai

A formázást az aktuális NumberFormatInfo objektum tulajdonságai befolyásolják, amelyet implicit módon az aktuális kulturális környezet vagy a IFormatProvider formázást meghívó metódus paramétere biztosít. Adjon meg egy NumberFormatInfo vagy CultureInfo objektumot a paraméterhez.

Megjegyzés

A numerikus értékek formázásához használt minták vagy sztringek testreszabásáról az osztály témakörében NumberFormatInfo olvashat.

Integrál és lebegőpontos numerikus típusok

A standard numerikus formátumok egyes leírásai az integrál- vagy lebegőpontos numerikus típusokra vonatkoznak. Az integrál numerikus típusok a következőkByte: , SByte, Int16, Int32, Int64, UInt16UInt32, UInt64és BigInteger. A lebegőpontos numerikus típusok a következők Decimal: , Half, Singleés Double.

Lebegőpontos végtelenségek és NaN

A formátumsztringtől függetlenül, ha egy Half, , vagy Double lebegőpontos típus értéke pozitív végtelen, negatív végtelen vagy nem szám (NaN), akkor a formázott sztring a megfelelő PositiveInfinitySymbol, , vagy NaNSymbol tulajdonság értéke, NegativeInfinitySymbolamelyet az aktuálisan alkalmazható NumberFormatInfoSingleobjektum határoz meg.

Mintakód

Az alábbi példa egy integrál és egy lebegőpontos numerikus értéket formáz az en-US kulturális környezet és az összes standard numerikus formátumkijelölő használatával. Ez a példa két konkrét numerikus típust használ (Double és ), de hasonló eredményeket adna a többi numerikus alaptípushoz (Byte, SByte, , Int16Int32, Int64, UInt32DecimalUInt64BigIntegerUInt16, Half, és ).SingleInt32

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}",
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}",
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}",
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"
Console.WriteLine("G: {0}",
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}",
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}",
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}",
        floating.ToString("R", ci));           // Displays "R: 10761.937554"
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // Displays "D: 008395"
Console.WriteLine("E: {0}",
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}",
        integral.ToString("F01", ci));         // Displays "F: 8395.0"
Console.WriteLine("G: {0}",
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}",
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}",
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 10761.937554
        Console.WriteLine("C: {0}", _
                floating.ToString("C", ci))           ' Displays "C: $10,761.94"
        Console.WriteLine("E: {0}", _
                floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
        Console.WriteLine("F: {0}", _
                floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
        Console.WriteLine("G: {0}", _
                floating.ToString("G", ci))           ' Displays "G: 10761.937554"
        Console.WriteLine("N: {0}", _
                floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
        Console.WriteLine("P: {0}", _
                (floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
        Console.WriteLine("R: {0}", _
                floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
        Console.WriteLine()

        ' Output integral values
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' Displays "D: 008395" 
        Console.WriteLine("E: {0}", _
                integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
        Console.WriteLine("F: {0}", _
                integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
        Console.WriteLine("G: {0}", _
                integral.ToString("G", ci))           ' Displays "G: 8395"
        Console.WriteLine("N: {0}", _
                integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
        Console.WriteLine("P: {0}", _
                (integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module

Lásd még