Udostępnij za pośrednictwem

Standardowe formaty liczbowe

Standardowe ciągi formatu liczbowego służą do formatowania typowych typów liczbowych. Standardowy ciąg formatu liczbowego przyjmuje formę [format specifier][precision specifier], gdzie:

  • Specyfikator formatu to pojedynczy znak alfabetyczny, który określa typ formatu liczbowego, na przykład walutę lub procent. Każdy ciąg formatu liczbowego, który zawiera więcej niż jeden znak alfabetyczny, w tym biały znak, jest interpretowany jako niestandardowy ciąg formatu liczbowego. Aby uzyskać więcej informacji, zobacz Niestandardowe ciągi formatu liczbowego.

  • Specyfikator dokładności to opcjonalna liczba całkowita, która wpływa na liczbę cyfr w wynikowym ciągu. W wersjach .NET 7 i nowszych maksymalna precyzja wynosi 999 999 999 999. W programie .NET 6 maksymalna wartość precyzji to Int32.MaxValue. W poprzednich wersjach platformy .NET precyzja może wynosić od 0 do 99. Specyfikator dokładności określa liczbę cyfr w ciągu reprezentującym liczbę. Nie zaokrągla samej liczby. Aby wykonać operację zaokrąglania, użyj Math.Ceilingmetody , Math.Floorlub Math.Round .

    Gdy specyfikator dokładności kontroluje liczbę cyfr ułamkowych w ciągu wynikowym, ciąg wynikowy odzwierciedla liczbę zaokrągloną do możliwego do reprezentowania wyniku najbliższego nieskończonie dokładnego wyniku. Jeśli istnieją dwa równie zbliżone do reprezentowania wyniki:

    • W programach .NET Framework i .NET Core do .NET Core 2.0 środowisko uruchomieniowe wybiera wynik z najmniej znaczącą cyfrą (czyli przy użyciu polecenia MidpointRounding.AwayFromZero).
    • W programie .NET Core 2.1 lub nowszym środowisko uruchomieniowe wybiera wynik z najmniej znaczącą cyfrą (czyli przy użyciu polecenia MidpointRounding.ToEven).

    Uwaga

    Specyfikator dokładności określa liczbę cyfr w ciągu wynikowym. Aby wypełnić ciąg wynikowy z wiodącymi lub końcowymi spacjami, użyj funkcji formatowania złożonego i zdefiniuj składnik szerokości w elemencie formatu.

Standardowe ciągi formatu liczbowego są obsługiwane przez:

Wskazówka

Możesz pobrać narzędzie formatowania, aplikację .NET Core Windows Forms, która umożliwia stosowanie ciągów formatu do wartości liczbowych lub daty i godziny oraz wyświetlania ciągu wyników. Kod źródłowy jest dostępny dla języka C# i Visual Basic.

Specyfikatory formatu standardowego

W poniższej tabeli opisano standardowe specyfikatory formatu liczbowego i przedstawiono przykładowe dane wyjściowe generowane przez każdy specyfikator formatu. Aby uzyskać dodatkowe informacje na temat używania standardowych ciągów formatu liczbowego, zobacz sekcjęPrzykład kodu , aby uzyskać kompleksową ilustrację ich użycia.

Wynik sformatowanego ciągu dla określonej kultury może się różnić od poniższych przykładów. Ustawienia systemu operacyjnego, ustawienia użytkownika, zmienne środowiskowe i używana wersja platformy .NET mogą mieć wpływ na format. Na przykład począwszy od platformy .NET 5 platforma .NET próbuje ujednolicić formaty kulturowe na różnych platformach. Aby uzyskać więcej informacji, zobacz Globalizacja platformy .NET i ICU.

Specyfikator formatu Nazwa Opis Przykłady
"B" lub "b" Dwójkowy Wynik: ciąg binarny.

Obsługiwane przez: tylko typy całkowite (.NET 8+).

Specyfikator dokładności: liczba cyfr w ciągu wynikowym.

Więcej informacji: Specyfikator formatu binarnego ("B").		 art. 42 ("B")
- Numer katalogowy 101010> TGL

255 ("B16")
-> 0000000011111111
"C" lub "c" Waluta Wynik: wartość waluty.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.CurrencyDecimalDigits.

Więcej informacji: Specyfikator formatu waluty ("C").		 123.456 ("C", en-US)
-> 123,46 zł

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" lub "d" Liczba dziesiętna Wynik: cyfry całkowite z opcjonalnym znakiem ujemnym.

Obsługiwane przez: tylko typy całkowite.

Specyfikator dokładności: minimalna liczba cyfr.

Domyślny specyfikator dokładności: wymagana minimalna liczba cyfr.

Więcej informacji: Specyfikator formatu Dziesiętnego("D").		 1234 ("D")
-> 1234 SZT.

-1234 ("D6")
-> -001234
"E" lub "e" Wykładniczy (naukowy) Wynik: notacja wykładnicza.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: 6.

Więcej informacji: Specyfikator formatu wykładniczego ("E").		 1052.032912756 ("E", en-US)
-> 1.052033E+003

1052.032912756 ("e", fr-FR)
-> 1052033e+003

-1052.032912756 ("e2", en-US)
-> -1.05e+003

-1052.032912756 ("E2", fr-FR)
-> -1,05E+003
"F" lub "f" Punkt stały Wynik: cyfry całkowite i dziesiętne z opcjonalnym znakiem ujemnym.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: Specyfikator formatu Fixed-Point ("F").		 1234,567 ("F", en-US)
-> 1234.57

1234.567 ("F", de-DE)
-> 1234,57 szt.

1234 ("F1", en-US)
-> 1234,0 szt.

1234 ("F1", de-DE)
-> 1234,0 szt.

-1234.56 ("F4", en-US)
-> -1234.5600

-1234.56 ("F4", de-DE)
-> -1234 5600 szt.
"G" lub "g" Ogólne Wynik: Bardziej kompaktowy zapis o stałym punkcie lub notacji naukowej.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr znaczących.

Domyślny specyfikator dokładności: zależy od typu liczbowego.

Więcej informacji: Specyfikator formatu ogólnego ("G").		 -123.456 ("G", en-US)
-> -123.456

-123,456 ("G", sv-SE)
-> -123 456 osób

123.4546 ("G4", en-US)
-> 123,5 pkt.

123.4546 ("G4", sv-SE)
-> 123,5 szt.

-1.234567890e-25 ("G", en-US)
-> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE)
-> -1,23456789E-25
"N" lub "n" Liczba Wynik: cyfry całkowite i dziesiętne, separatory grup i separator dziesiętny z opcjonalnym znakiem ujemnym.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: żądana liczba miejsc dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: Specyfikator formatu liczbowego ("N").		 1234.567 ("N", en-US)
-> 1,234,57

1234.567 ("N", ru-RU)
-> 1 234 57

1234 ("N1", en-US)
-> 1234.0

1234 ("N1", ru-RU)
-> 1 234,0 szt.

-1234.56 ("N3", en-US)
-> -1 234 560 zł

-1234.56 ("N3", ru-RU)
-> -1 234 560
"P" lub "p" Procent Wynik: liczba pomnożona przez 100 i wyświetlana z symbolem procentu.

Obsługiwane przez: wszystkie typy liczbowe.

Specyfikator dokładności: żądana liczba miejsc dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.PercentDecimalDigits.

Więcej informacji: Specyfikator formatu procentu ("P").		 1 ("P", en-US)
-> 100,00 %

1 ("P", fr-FR)
-> 100 00 %

-0,39678 ("P1", en-US)
-> -39,7 %

-0,39678 ("P1", fr-FR)
-> -39,7 %
"R" lub "r" Błądzenia Wynik: ciąg, który może zaokrąglać liczbę do identycznej liczby.

Obsługiwane przez: Single, Doublei BigInteger.

Uwaga: zalecane tylko dla BigInteger typu. W przypadku typów użyj "G17"; w przypadku DoubleSingle typów użyj "G9".
Specyfikator dokładności: ignorowany.

Więcej informacji: Specyfikator formatu round-trip ("R").		 123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" lub "x" Szesnastkowy Wynik: ciąg szesnastkowy.

Obsługiwane przez: tylko typy całkowite.

Specyfikator dokładności: liczba cyfr w ciągu wynikowym.

Więcej informacji: Specyfikator formatu szesnastkowego ("X").		 255 ("X")
-> FF (Nie)

-1 ("x")
-> ff

255 ("x4")
-> 00ff (strona tysiącst)

-1 ("X4")
-> 00FF (Księga Śródstopna)
Dowolny inny pojedynczy znak Nieznany specyfikator Wynik: zgłasza FormatException błąd w czasie wykonywania.

Używanie standardowych ciągów formatu liczbowego

Uwaga

Przykłady języka C# w tym artykule działają w Try.NET wbudowanym modułem uruchamiającym kod i placem zabaw. Wybierz przycisk Uruchom , aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu można go zmodyfikować i uruchomić zmodyfikowany kod, wybierając pozycję Uruchom ponownie. Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub, jeśli kompilacja zakończy się niepowodzeniem, w oknie interaktywnym zostaną wyświetlone wszystkie komunikaty o błędach kompilatora języka C#.

Standardowy ciąg formatu liczbowego może służyć do definiowania formatowania wartości liczbowej w jeden z następujących sposobów:

  • Można go przekazać do TryFormat metody lub przeciążenia ToString metody, która ma format parametr. Poniższy przykład formatuje wartość liczbową jako ciąg waluty w bieżącej kulturze (w tym przypadku en-US kultury).

    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

  • Można go podać jako formatString argument w elemencie formatu używanym z takimi metodami jak String.Format, Console.WriteLinei StringBuilder.AppendFormat. Aby uzyskać więcej informacji, zobacz Formatowanie złożone. W poniższym przykładzie użyto elementu formatu do wstawienia wartości waluty w ciągu.

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

    Opcjonalnie możesz podać alignment argument, aby określić szerokość pola liczbowego i określić, czy jego wartość jest wyrównana do prawej, czy lewej. Poniższy przykład wyrównuje wartość waluty w polu 28 znaków i wyrównuje wartość waluty w polu 14-znakowym.

    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

  • Można go podać jako formatString argument w elemencie wyrażenia interpolowanego ciągu interpolowanego. Aby uzyskać więcej informacji, zobacz artykuł Interpolacja ciągów w dokumentacji języka C# lub artykuł Ciągi interpolowane w dokumentacji języka Visual Basic.

Poniższe sekcje zawierają szczegółowe informacje na temat każdego ze standardowych ciągów formatu liczbowego.

Specyfikator formatu binarnego (B)

Specyfikator formatu binarnego ("B") konwertuje liczbę na ciąg cyfr binarnych. Ten format jest obsługiwany tylko w przypadku typów całkowitych i tylko na platformie .NET 8+.

Specyfikator dokładności wskazuje minimalną liczbę cyfr żądanych w wynikowym ciągu. Jeśli jest to wymagane, liczba jest dopełniana zerami po lewej stronie, aby wygenerować liczbę cyfr podanych przez specyfikator dokładności.

Ciąg wynikowy nie ma wpływu na informacje o formatowaniu bieżącego NumberFormatInfo obiektu.

Specyfikator formatu waluty (C)

Specyfikator formatu "C" (lub waluty) konwertuje liczbę na ciąg reprezentujący kwotę waluty. Specyfikator dokładności wskazuje żądaną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli specyfikator dokładności zostanie pominięty, domyślna precyzja jest definiowana NumberFormatInfo.CurrencyDecimalDigits przez właściwość .

Jeśli wartość do sformatowania ma więcej niż określona lub domyślna liczba miejsc dziesiętnych, wartość ułamkowa jest zaokrąglana w ciągu wynikowym. Jeśli wartość po prawej stronie liczby określonych miejsc dziesiętnych wynosi 5 lub więcej, ostatnia cyfra w ciągu wynikowym jest zaokrąglona od zera.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
CurrencyPositivePattern Definiuje umieszczanie symbolu waluty dla wartości dodatnich.
CurrencyNegativePattern Definiuje położenie symbolu waluty dla wartości ujemnych i określa, czy znak ujemny jest reprezentowany przez nawiasy lub NegativeSign właściwość.
NegativeSign Definiuje używany znak ujemny, jeśli CurrencyNegativePattern wskazuje, że nawiasy nie są używane.
CurrencySymbol Definiuje symbol waluty.
CurrencyDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości waluty. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.
CurrencyDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i dziesiętne.
CurrencyGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
CurrencyGroupSizes Definiuje liczbę cyfr całkowitych wyświetlanych w grupie.

Poniższy przykład formatuje Double wartość za pomocą specyfikatora formatu waluty:

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

Specyfikator formatu dziesiętnego (D)

Specyfikator formatu "D" (lub dziesiętny) konwertuje liczbę na ciąg cyfr dziesiętnych (0–9), poprzedzony znakiem minus, jeśli liczba jest ujemna. Ten format jest obsługiwany tylko w przypadku typów całkowitych.

Specyfikator dokładności wskazuje minimalną liczbę cyfr żądanych w wynikowym ciągu. Jeśli jest to wymagane, liczba jest dopełniana zerami po lewej stronie, aby wygenerować liczbę cyfr podanych przez specyfikator dokładności. Jeśli nie określono specyfikatora dokładności, wartość domyślna to minimalna wartość wymagana do reprezentowania liczby całkowitej bez zer wiodących.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. Jak pokazano w poniższej tabeli, jedna właściwość wpływa na formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.

Poniższy przykład formatuje Int32 wartość z specyfikatorem formatu dziesiętnego.

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

Specyfikator formatu wykładniczego (E)

Specyfikator formatu wykładniczego ("E") konwertuje liczbę na ciąg formularza "-dddd... E+ddd" lub "-d.ddd... e+ddd", gdzie każdy "d" wskazuje cyfrę (0–9). Ciąg zaczyna się od znaku minus, jeśli liczba jest ujemna. Dokładnie jedna cyfra zawsze poprzedza punkt dziesiętny.

Specyfikator dokładności wskazuje żądaną liczbę cyfr po przecinku dziesiętnego. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta wartość domyślna sześciu cyfr po przecinku dziesiętnym.

Przypadek specyfikatora formatu wskazuje, czy prefiks wykładnika z literą "E" lub "e". Wykładnik zawsze składa się z znaku plus lub minus i co najmniej trzech cyfr. Wykładnik jest wypełniony zerami, aby spełnić to minimum, jeśli jest to wymagane.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna zarówno dla współczynnika, jak i wykładnika.
NumberDecimalSeparator Definiuje ciąg, który oddziela cyfrę całkowitą od cyfr dziesiętnych w współczynniku.
PositiveSign Definiuje ciąg wskazujący, że wykładnik jest dodatni.

Poniższy przykład formatuje Double wartość za pomocą specyfikatora formatu wykładniczego:

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

Specyfikator formatu stałego punktu (F)

Specyfikator formatu o stałym punkcie ("F") konwertuje liczbę na ciąg formularza "-dddd.ddd..." gdzie każdy znak "d" wskazuje cyfrę (0–9). Ciąg zaczyna się od znaku minus, jeśli liczba jest ujemna.

Specyfikator dokładności wskazuje żądaną liczbę miejsc dziesiętnych. Jeśli specyfikator dokładności zostanie pominięty, bieżąca NumberFormatInfo.NumberDecimalDigits właściwość dostarcza precyzję liczbową.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono właściwości NumberFormatInfo obiektu, które kontrolują formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.

Poniższy przykład formatuje Double wartość i Int32 z specyfikatorem formatu stałego punktu:

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

Specyfikator formatu ogólnego (G)

Ogólny specyfikator formatu ("G") konwertuje liczbę na bardziej kompaktową notację o stałym punkcie lub notacji naukowej, w zależności od typu liczby i tego, czy specyfikator dokładności jest obecny. Specyfikator dokładności definiuje maksymalną liczbę cyfr znaczących, które mogą pojawić się w ciągu wynikowym. Jeśli specyfikator dokładności zostanie pominięty lub zero, typ liczby określa domyślną precyzję, jak wskazano w poniższej tabeli.

Typ liczbowy Domyślna precyzja
Byte lub SByte 3 cyfry
Int16 lub UInt16 5 cyfr
Int32 lub UInt32 10 cyfr
Int64 19 cyfr
UInt64 20 cyfr
BigInteger Nieograniczona (taka sama jak "R")
Half Najmniejsza zaokrąglalna liczba cyfr reprezentujących liczbę
Single Najmniejsza zaokrąglona liczba cyfr reprezentujących liczbę (w programie .NET Framework G7 jest domyślna)
Double Najmniejsza zaokrąglona liczba cyfr reprezentujących liczbę (w programie .NET Framework G15 jest domyślna)
Decimal Najmniejsza zaokrąglalna liczba cyfr reprezentujących liczbę

Notacja o stałym punkcie jest używana, jeśli wykładnik, który wynikałby z wyrażenia liczby w notacji naukowej, jest większy niż -5 i mniejszy niż specyfikator dokładności; w przeciwnym razie używana jest notacja naukowa. Wynik zawiera punkt dziesiętny, jeśli jest to wymagane, a końcowe zera po pominięciu punktu dziesiętnego. Jeśli specyfikator dokładności jest obecny i liczba cyfr znaczących w wyniku przekracza określoną precyzję, nadmiar cyfr końcowych jest usuwany przez zaokrąglanie.

Jeśli jednak liczba jest liczbą Decimal i specyfikator dokładności zostanie pominięty, notacja o stałym punkcie jest zawsze używana, a końcowe zera są zachowywane.

Jeśli jest używana notacja naukowa, wykładnik w wyniku jest poprzedzony prefiksem "E", jeśli specyfikator formatu to "G", lub "e", jeśli specyfikator formatu to "g". Wykładnik zawiera co najmniej dwie cyfry. Różni się to od formatu notacji naukowej generowanej przez specyfikator formatu wykładniczego, który zawiera co najmniej trzy cyfry w wykładnik.

W przypadku użycia z wartością Double specyfikator formatu "G17" gwarantuje, że oryginalna Double wartość została pomyślnie zaokrąglony. Dzieje się tak, ponieważ Double jest to liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 o podwójnej precyzji (binary64), która daje do 17 znaczących cyfr precyzji. W programie .NET Framework zalecamy użycie go zamiast specyfikatora formatu "R", ponieważ w niektórych przypadkach wartość zmiennoprzecinkowa o podwójnej precyzji kończy się niepowodzeniem .R.

W przypadku użycia z wartością Single specyfikator formatu "G9" gwarantuje, że oryginalna Single wartość została pomyślnie zaokrąglony. Dzieje się tak, ponieważ Single jest to liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 o pojedynczej precyzji (binary32), która daje do dziewięciu znaczących cyfr precyzji. Ze względów wydajności zalecamy użycie go zamiast specyfikatora formatu "R".

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Definiuje ciąg wskazujący, że wykładnik jest dodatni.

Poniższy przykład formatuje assortowane wartości zmiennoprzecinkowe z ogólnym specyfikatorem formatu:

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

Specyfikator formatu liczbowego (N)

Specyfikator formatu liczbowego ("N") konwertuje liczbę na ciąg formularza "-d,ddd,ddd.ddd...", gdzie "-" wskazuje symbol liczby ujemnej, jeśli jest to wymagane, "d" wskazuje cyfrę (0–9), "", wskazuje separator grupy i "." wskazuje symbol dziesiętny. Specyfikator dokładności wskazuje żądaną liczbę cyfr po przecinku dziesiętnego. Jeśli specyfikator dokładności zostanie pominięty, liczba miejsc dziesiętnych jest definiowana przez bieżącą NumberFormatInfo.NumberDecimalDigits właściwość.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.
NumberNegativePattern Definiuje format wartości ujemnych i określa, czy znak ujemny jest reprezentowany przez nawiasy, czy NegativeSign właściwość .
NumberGroupSizes Definiuje liczbę cyfr całkowitych, które pojawiają się między separatorami grup.
NumberGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i dziesiętne.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.

Poniższy przykład formatuje assortowane wartości zmiennoprzecinkowe z specyfikatorem formatu liczb:

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

Specyfikator formatu procentu (P)

Specyfikator formatu procentu ("P") mnoży liczbę przez 100 i konwertuje ją na ciąg reprezentujący wartość procentową. Specyfikator dokładności wskazuje żądaną liczbę miejsc dziesiętnych. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta domyślna precyzja liczbowa podana przez bieżącą PercentDecimalDigits właściwość.

W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
PercentPositivePattern Definiuje umieszczanie symbolu procentu dla wartości dodatnich.
PercentNegativePattern Definiuje umieszczanie symbolu procentu i symbolu ujemnego dla wartości ujemnych.
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.
PercentSymbol Definiuje symbol procentu.
PercentDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości procentowej. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.
PercentDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i dziesiętne.
PercentGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
PercentGroupSizes Definiuje liczbę cyfr całkowitych wyświetlanych w grupie.

Poniższy przykład formatuje wartości zmiennoprzecinkowe za pomocą specyfikatora formatu procentu:

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 %

Specyfikator formatu dwukierunkowego (R)

Specyfikator formatu dwukierunkowego ("R") próbuje upewnić się, że wartość liczbowa przekonwertowana na ciąg jest analizowana z powrotem na tę samą wartość liczbową. Ten format jest obsługiwany tylko dla Halftypów , Single, Doublei BigInteger .

W programie .NET Framework i w wersjach platformy .NET Core wcześniejszych niż 3.0 specyfikator formatu "R" nie może pomyślnie Double zaokrąglić wartości w niektórych przypadkach. W przypadku wartości i DoubleSingle specyfikator formatu "R" oferuje stosunkowo niską wydajność. Zamiast tego zalecamy użycie specyfikatora formatu "G17" dla Double wartości i specyfikatora formatu "G9" , aby pomyślnie zaokrąglić Single wartości.

BigInteger Gdy wartość jest formatowana przy użyciu tego specyfikatora, jego reprezentacja ciągu zawiera wszystkie cyfry znaczące w BigInteger wartości.

Chociaż można uwzględnić specyfikator dokładności, jest ignorowany. W przypadku używania tego specyfikatora pierwszeństwo przed zaokrąglonymi podróżami ma pierwszeństwo przed precyzją. Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg wskazujący, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Definiuje ciąg wskazujący, że wykładnik jest dodatni.

Poniższy przykład formatuje BigInteger wartość za pomocą specyfikatora formatu dwukierunkowego.

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

Ważne

W niektórych przypadkach Double wartości sformatowane przy użyciu standardowego ciągu formatu liczbowego "R" nie są pomyślnie zaokrąglane w przypadku kompilowania przy użyciu /platform:x64 przełączników lub /platform:anycpu i uruchamiania w systemach 64-bitowych. Aby uzyskać więcej informacji, zobacz następujący akapit.

Aby obejść problem Double wartości sformatowanych przy użyciu standardowego ciągu formatu liczbowego "R" nie udało się pomyślnie zaokrąglić, jeśli skompilowane przy użyciu /platform:x64 przełączników lub /platform:anycpu i działać w systemach 64-bitowych, można sformatować Double wartości przy użyciu standardowego ciągu formatu liczbowego "G17". W poniższym przykładzie użyto ciągu formatu "R" z wartością Double , która nie powiodła się, a także używa ciągu formatu "G17", aby pomyślnie zaokrąglić oryginalną wartość:

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

Specyfikator formatu szesnastkowego (X)

Specyfikator formatu szesnastkowego ("X") konwertuje liczbę na ciąg cyfr szesnastkowych. Przypadek specyfikatora formatu wskazuje, czy używać wielkich lub małych liter dla cyfr szesnastkowej, które są większe niż 9. Na przykład użyj "X", aby utworzyć "ABCDEF" i "x", aby utworzyć "abcdef". Ten format jest obsługiwany tylko w przypadku typów całkowitych.

Specyfikator dokładności wskazuje minimalną liczbę cyfr żądanych w wynikowym ciągu. Jeśli jest to wymagane, liczba jest dopełniana zerami po lewej stronie, aby wygenerować liczbę cyfr podanych przez specyfikator dokładności.

Ciąg wynikowy nie ma wpływu na informacje o formatowaniu bieżącego NumberFormatInfo obiektu.

Poniższy przykład formatuje Int32 wartości z specyfikatorem formatu szesnastkowego.

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

Notatki

Ta sekcja zawiera dodatkowe informacje na temat używania standardowych ciągów formatu liczbowego.

Ustawienia panelu sterowania

Ustawienia w elemencie Opcje regionalne i językowe w Panelu sterowania mają wpływ na ciąg wynikowy utworzony przez operację formatowania. Te ustawienia służą do inicjowania NumberFormatInfo obiektu skojarzonego z bieżącą kulturą, która udostępnia wartości używane do zarządzania formatowaniem. Komputery korzystające z różnych ustawień generują różne ciągi wyników.

Ponadto jeśli CultureInfo(String) konstruktor jest używany do tworzenia wystąpienia nowego CultureInfo obiektu, który reprezentuje tę samą kulturę co bieżąca kultura systemu, wszelkie dostosowania ustanowione przez element Opcje regionalne i językowe w Panelu sterowania zostaną zastosowane do nowego CultureInfo obiektu. Konstruktor umożliwia CultureInfo(String, Boolean) utworzenie CultureInfo obiektu, który nie odzwierciedla dostosowań systemu.

Właściwości NumberFormatInfo

Formatowanie ma wpływ na właściwości bieżącego NumberFormatInfo obiektu, który jest dostarczany niejawnie przez bieżącą kulturę lub jawnie przez IFormatProvider parametr metody, która wywołuje formatowanie. NumberFormatInfo Określ obiekt lub CultureInfo dla tego parametru.

Uwaga

Aby uzyskać informacje na temat dostosowywania wzorców lub ciągów używanych w formatowaniu wartości liczbowych, zobacz NumberFormatInfo temat klasy.

Typy liczb całkowitych i zmiennoprzecinkowych

Niektóre opisy standardowych specyfikatorów formatu liczbowego odnoszą się do typów liczb całkowitych lub zmiennoprzecinkowych. Typy liczb całkowitych to Byte, , SByte, Int16Int32Int64UInt16, UInt32, , UInt64, i .BigInteger Typy liczb zmiennoprzecinkowe to Decimal, Half, Singlei Double.

Liczba zmiennoprzecinkowa i naN

Niezależnie od ciągu formatu, jeśli wartość Halftypu , Singlelub Double zmiennoprzecinkowego jest dodatnią nieskończonością, nieskończonością ujemną, a nie liczbą (NaN), sformatowany ciąg jest wartością odpowiedniej PositiveInfinitySymbolwłaściwości , NegativeInfinitySymbollub NaNSymbol określonej przez aktualnie odpowiedni NumberFormatInfo obiekt.

Przykład kodu

Poniższy przykład formatuje całkowitą i zmiennoprzecinkową wartość liczbową przy użyciu kultury en-US i wszystkich standardowych specyfikatorów formatu liczbowego. W tym przykładzie użyto dwóch konkretnych typów liczbowych (Double i ), ale daje podobne wyniki dla dowolnego z innych typów podstawowych liczb (Int32, Byte, SByteInt16Int32Int64UInt16UInt32UInt64BigInteger, Decimal, i ).HalfSingle

// 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

Zobacz też