Megosztás a következőn keresztül:

Standard numerikus formátumú karakterláncok

A standard numerikus formátumú sztringek a gyakori numerikus típusok formázására szolgálnak. A standard numerikus formátumú sztring az űrlap [format specifier][precision specifier], ahol:

  • A Formátumjelölő egy betűrendes karakter, amely megadja a számformátum típusát, például pénznemet vagy százalékot. Minden numerikus formázási sztring, amely több betűrendbeli karaktert tartalmaz, beleértve a szóközt is, egyéni numerikus formátumsztringként értelmezendő. 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 999. A .NET 6-ban a pontosság maximális értéke .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 sztring-ábrázolásának számjegyeinek számát vezérli. A szám nem kerekítése. Kerekítési művelet végrehajtásához használja az Math.Ceiling, Math.Floorvagy Math.Round metódust.

    Amikor a pontosság-meghatározó szabályozza az eredménysztring törtjegyeinek számát, az eredménysztring egy olyan számot tükröz, amely a végtelenül pontos eredményhez legközelebbi, ábrázolható eredményre kerekítve van. Ha két egyenlően közel ábrázolható eredmény van:

    • A .NET-keretrendszeren és a .NET Core-on a .NET Core 2.0-ig a futtatókörnyezet az eredményt a legkisebb jelentős számjegygel (azaz a használatával MidpointRounding.AwayFromZero) választja ki.
    • A .NET Core 2.1-ben és újabb verzióiban a futtatókörnyezet az eredményt még a legkevésbé jelentős számjeggyel (azaz a használatával MidpointRounding.ToEven) választja ki.

    Megjegyzés

    A pontosság-meghatározó határozza meg az eredménysztring számjegyeinek számát. Ha kezdő vagy záró szóközökkel szeretne egy eredménysztringet beszúrni, használja az összetett formázási funkciót, és definiáljon egy szélességi összetevőt a formázási elemben.

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ási 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 a szabványos numerikus formátumkijelölőket ismerteti, és megjeleníti az egyes formátumkijelölő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, valamint a Kód példa 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 kezdve például a .NET megpróbálja egyesíteni a különböző platformok kulturális formátumát. További információ: .NET-globalizáció és ICU.

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énysztring számjegyeinek száma.

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

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

Támogatja: Minden numerikus típus.

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

Alapértelmezett pontosság-meghatározó: A megadott érték 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" Decimális Eredmény: Egész szám, opcionális negatív előjellel.

Támogatott: Csak integráltípusok.

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

Alapértelmezett pontosság-meghatározó: A szükséges számjegyek minimális száma.

További információ: The Decimal("D") Format Specifier.		 1234 ("D")
-> 1234

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

Támogatja: 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 tizedesjegyek opcionális negatív előjellel.

Támogatja: Minden numerikus típus.

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

Alapértelmezett pontosság-meghatározó: A megadott érték 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 Eredmény: A rögzített pont vagy a tudományos jelölés tömörebb.

Támogatja: Minden numerikus típus.

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

Alapértelmezett pontosság-meghatározó: 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 nem kötelező negatív előjellel rendelkező tizedeselválasztó.

Támogatja: Minden numerikus típus.

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

Alapértelmezett pontosság-meghatározó: A megadott érték 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ámogatja: Minden numerikus típus.

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

Alapértelmezett pontosság-meghatározó: A megadott érték NumberFormatInfo.PercentDecimalDigits: .

További információ: The Percent ("P") Format Specifier.		 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 azonos számra kerekítheti az utat.

Támogatja: Single, Doubleés BigInteger.

Megjegyzés: Csak a BigInteger típushoz ajánlott. Típusok esetén Double használja a "G17" értéket; a típusokhoz használja a Single "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 integráltípusok.

Pontosság-meghatározó: Az eredménysztring számjegyeinek 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 egyetlen karakter Ismeretlen meghatározó Eredmény: Futásidőben dob.FormatException

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ása 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 ismételt futtatásával. A módosított kód vagy az interaktív ablakban fut, vagy ha a fordítás sikertelen, az interaktív ablakban megjelenik az összes C#-fordító hibaüzenet.

A numerikus értékek formázásának meghatározásához szabványos numerikus formázási sztring használható az alábbi módok egyikével:

  • Á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 a en-US kultúrában).

    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ó egy formatString olyan formátumelemben, amely olyan metódusokkal használható, mint az String.Format, 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 = 123.456m;
Console.WriteLine($"Your account balance is {value:C2}.");
// 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."

    Igény szerint megadhat egy alignment argumentumot a numerikus mező szélességének megadásához, illetve annak jobb vagy bal igazítású értékéhez. 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.

    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ókért tekintse meg a Sztring interpolációs cikkét a C# hivatkozásban, vagy az Interpolált sztringek cikket a Visual Basic-referenciaban.

A következő 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. Szükség esetén 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ásához.

Az eredménysztringet nem érinti az aktuális NumberFormatInfo objektum formázási információja.

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

A "C" (vagy pénznem) formátumválasztó 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 annál nagyobb, az eredménysztring utolsó számjegye nullától távolra kerekítve lesz.

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 A pozitív értékek pénznemszimbólumának elhelyezését határozza meg.
CurrencyNegativePattern Meghatározza a negatív értékek pénznemszimbólumának elhelyezését, és megadja, hogy a negatív jelet zárójelek vagy a NegativeSign tulajdonság jelöli-e.
NegativeSign Meghatározza a használt negatív előjelet, ha CurrencyNegativePattern azt jelzi, hogy a zárójelek nincsenek használatban.
CurrencySymbol Meghatározza a pénznemszimbólumot.
CurrencyDecimalDigits A pénznemértékben szereplő tizedesjegyek alapértelmezett számát határozza meg. Ezt az értéket felül lehet bírálni a pontosság-meghatározó használatával.
CurrencyDecimalSeparator Meghatározza az integrál- és tizedesjegyeket elválasztó sztringet.
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-meghatározóval:

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átumválasztó (D)

A "D" (vagy decimális) formátumválasztó decimális számjegyek sztringjéhez (0-9) konvertálja a számot, amelyet mínuszjel előtaggal előtaggal jelöl, 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. Szükség esetén 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ásához. Ha nincs megadva pontosságkijelölő, 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 egy Int32 értéket formáz a decimális formátumjelölővel.

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.dddd... E+ddd" vagy "-d.dddd... e+ddd", ahol minden "d" egy 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-meghatározó nincs megadva, a tizedesvesszőt követő hat számjegy alapértelmezett értéke.

A formátumjelölő esete azt jelzi, hogy a kitevőt "E" vagy "e" előtaggal kell-e előtaggal előtagként hozzáadni. A kitevő mindig plusz vagy mínuszjelből és legalább három számjegyből áll. A kitevő nullákkal van kipárnázva, hogy szükség esetén megfeleljen ennek a minimumnak.

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 mind az együttható, mind a kitevő esetében.
NumberDecimalSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számjegyet a tizedesjegyektől az együtthatóban.
PositiveSign Meghatározza azt a sztringet, amely azt jelzi, hogy egy kitevő pozitív.

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

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ő a számot a "-ddd.ddd..." űrlap sztringjeként alakítja át. ahol minden "d" egy számjegyet jelöl (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-meghatározó nincs megadva, 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 vezérlő objektum tulajdonságait NumberFormatInfo 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 felül lehet bírálni a pontosság-meghatározó használatával.

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

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ő egy számot rögzített vagy tudományos jelölés tömörebbre alakít át, a szám típusától és a pontosság meghatározásától függően. 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-kijelölő nincs megadva 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ámnak a legkisebb, ciklikusan három számjegyből álló száma
Single A szám legkisebb ciklikusan három számjegyből áll (a .NET-keretrendszerben a G7 az alapértelmezett)
Double A számnak a legkisebb, három számjegyből álló száma (a .NET-keretrendszerben a G15 az alapértelmezett)
Decimal A számnak a legkisebb, ciklikusan három számjegyből álló száma

Rögzítettpontos jelölést akkor használunk, ha a szám tudományos jelölésben való kifejezéséből eredő kitevő nagyobb, mint -5 és kisebb, mint a pontosság-meghatározó; egyéb esetben tudományos jelölést használnak. Az eredmény szükség esetén tizedesvesszőt tartalmaz, é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 rendszer kerekítéssel eltávolítja a felesleges záró számjegyeket.

Ha azonban a szám egy Decimal , és a pontosság-meghatározó nincs megadva, a rögzített pont jelölése mindig használatos, és a záró nullák megmaradnak.

Tudományos jelölés használata esetén az eredmény kitevője "E" előtaggal lesz előtaggal elnevezve, 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átumkijelölő biztosítja, hogy az eredeti Double érték sikeresen kerekedik. 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. A .NET-keretrendszerben az "R" formátumjelölő helyett azt javasoljuk, hogy használja, mivel bizonyos esetekben az "R" nem sikerül a dupla pontosságú lebegőpontos értékek bejárása.

Ha egy értékkel használja Single , a "G9" formátumkijelö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 is ad. Teljesítménybeli okokból az "R" formátumjelölő helyett a használatát javasoljuk.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. 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 formázza az általános formátumkijelölővel:

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..." formátumú sztringgé alakítja, ahol a "-" negatív számszimbólumot jelez, ha szükséges, 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-meghatározó nincs megadva, a tizedesjegyek számát az aktuális NumberFormatInfo.NumberDecimalDigits tulajdonság határozza meg.

Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. 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öli-e.
NumberGroupSizes Meghatározza a csoportelválasztók között megjelenő szerves számjegyek számát.
NumberGroupSeparator Meghatározza azt a sztringet, amely elválasztja az integrál számok csoportjait.
NumberDecimalSeparator Meghatározza az integrál- és tizedesjegyeket elválasztó sztringet.
NumberDecimalDigits Meghatározza a tizedesjegyek alapértelmezett számát. Ez az érték egy pontosság-meghatározó használatával felülírható.

Az alábbi példa a számformátum-megjelö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

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-meghatározó (P)

A százalék ("P") formátumválasztó megszorozza a számot 100-tal, és százalékot képviselő sztringgé alakítja. A pontosság-meghatározó a tizedesjegyek kívánt számát jelzi. Ha a pontosság-meghatározó 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 a NumberFormatInfo visszaadott sztring formázását vezérlő tulajdonságokat sorolja fel.

NumberFormatInfo tulajdonság Leírás
PercentPositivePattern A pozitív értékek százalékos szimbó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 az integrál- és tizedesjegyeket elválasztó sztringet.
PercentGroupSeparator Meghatározza azt a sztringet, amely elválasztja az integrál 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-meghatározóval 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 %

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 %

Oda-vissza formátumválasztó (R)

Az oda-vissza ("R") formátumkijelölő megkísérli biztosítani, hogy a sztringgé konvertált numerikus értékeket a rendszer ugyanabba a numerikus értékbe értelmezi vissza. Ez a formátum csak a Half, Single, Doubleés BigInteger a típusok esetében támogatott.

A .NET-keretrendszerben és a 3.0-nál korábbi .NET Core-verziókban az "R" formátumjelölő bizonyos esetekben nem tud sikeresen kerekíteni Double az értékeket. Az "R" formátumkijelölő mindkettőhöz Double és Single értékhez 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 az oda-vissza értékek sikeres lekerekítéséhez Single .

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

Bár megadhat egy pontossági azonosítót, a függvény figyelmen kívül hagyja. A kerek utak elsőbbséget élveznek a precizitással szemben, ha ezt a kijelölőt használják. Az eredménysztringet az aktuális NumberFormatInfo objektum formázási információi befolyásolják. 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átum megadójával.

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ázási sztringdel formázott értékek nem járnak sikerrel, ha azokat a /platform:x64 kapcsolókkal vagy /platform:anycpu kapcsolókkal fordítják le, és 64 bites rendszereken futnak. További információt a következő bekezdésben talál.

Az "R" standard numerikus formázási sztringdel formázott értékek problémájának Double megoldásához, ha a 64 bites rendszereken történő fordítás vagy /platform:x64 kapcsolók használatával /platform:anycpu történik, az értékeket a "G17" standard numerikus formátum sztring használatával formázhatjaDouble. 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($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");

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($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// 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':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       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':
'       .NET Framework:
'       0.6822871999174 = 0.68228719991740006: False
'       .NET:
'       0.6822871999174 = 0.6822871999174: True
'
'       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ő egy számot hexadecimális számjegyek sztringjé alakít át. A formátumjelölő esete azt jelzi, hogy a 9-nél nagyobb hexadecimális számjegyekhez nagybetűs vagy kisbetűs karaktereket kell-e használni. Az "X" például az "ABCDEF" előállításához, az "x" pedig az "abcdef" előállításához használható. 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. Szükség esetén 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ásához.

Az eredménysztringet nem érinti az aktuális NumberFormatInfo objektum formázási információja.

Az alábbi példa a 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

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ásai

A Vezérlőpult Területi és nyelvi beállítások elemének beállításai befolyásolják a formázási művelet által létrehozott eredménysztringet. Ezek a beállítások az aktuális kultúrához társított objektum inicializálására NumberFormatInfo szolgálnak, 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.

Ezenkívül ha a CultureInfo(String) konstruktor egy olyan új CultureInfo objektum példányosítására szolgál, amely az aktuális rendszerkultúra kultúrájával megegyező kultúrát képviseli, a Vezérlőpult Területi és nyelvi beállítások eleme á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ását.

NumberFormatInfo tulajdonságai

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

Megjegyzés

A numerikus értékek formázásához használt minták és 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 integrál- vagy lebegőpontos numerikus típusokra vonatkoznak. Az integrál numerikus típusok a következőkByte: , SByteInt16, , Int32, Int64UInt16, UInt32, UInt64és BigInteger. A lebegőpontos numerikus típusok a következőkDecimal: , HalfSingleés Double.

Lebegőpontos végtelenségek és NaN

A formázási sztringtől függetlenül, ha egy Half, Single, vagy Double lebegőpontos típus értéke pozitív végtelen, negatív végtelen vagy nem szám (NaN), a formázott sztring az adott PositiveInfinitySymbol, NegativeInfinitySymbolvagy NaNSymbol az aktuálisan alkalmazható NumberFormatInfo objektum által megadott tulajdonság értéke.

Kódrészlet

Az alábbi példa egy integrál és egy lebegőpontos numerikus értéket formáz a en-US kultúra és az összes standard numerikus formátumjelölő használatával. Ez a példa két adott numerikus típust használ (Double és Int32), de hasonló eredményeket adna a többi numerikus alaptípushoz (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32UInt64, BigIntegerDecimal, Halfés 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: {floating.ToString("C", ci)}");           // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}");         // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}");         // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}");           // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}");         // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}");           // Displays "R: 10761.937554"
Console.WriteLine();

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