Udostępnij za pośrednictwem

Standardowe ciągi formatujące liczby

  • Artykuł

Ciągi standardowych formatów liczb służą do formatowania popularnych 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. Dowolny ciąg formatu liczb, który zawiera więcej niż jeden znak alfabetyczny, w tym znak odstępu, jest interpretowany jako ciąg niestandardowego formatu liczb. 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 metody Math.Ceiling, 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 platformy .NET Core 2.0środowisko uruchomieniowe wybiera wynik z najmniej znaczącą cyfrą (czyli przy użyciu MidpointRounding.AwayFromZero).
    • w programie .NET Core 2.1 lub nowszymśrodowisko uruchomieniowe wybiera wynik z co najmniej znaczącą cyfrą (czyli przy użyciu MidpointRounding.ToEven).

    Uwaga

    Specyfikator dokładności określa liczbę cyfr w ciągu wynikowym. Aby wypełnić ciąg wyników spacjami wiodącymi lub końcowymi, użyj funkcji formatowania złożonego i zdefiniuj składnik wyrównania 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 i wyświetla ciąg wyniku. Kod źródłowy jest dostępny dla 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ę Notes Oraz sekcję Code example (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").		 42 ("B")
-> 101010

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

Obsługiwany 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

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: liczby całkowite z opcjonalnym znakiem minus.

Obsługiwane przez: tylko typy całkowite.

Specyfikator dokładności: minimalna liczba cyfr.

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

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

-1234 ("D6")
-> -001234
„E” lub „e” Wartość wykładnicza (naukowa) Wynik: zapis wykładniczy.

Obsługiwany 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” Wartość stałoprzecinkowa Wynik: cyfry całkowite i dziesiętne z opcjonalnym znakiem minus.

Obsługiwany 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 stałego punktu ("F").		 1234.567 ("F", en-US)
-> 1234.57

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

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

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

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

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

Obsługiwany 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

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” lub „n” Liczba Wynik: cyfry całkowite i dziesiętne, separatory grup i separator dziesiętny z opcjonalnym znaku minus.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: wymagana 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

-1234.56 ("N3", en-US)
-> -1,234.560

-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ługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: wymagana 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 typu BigInteger. W przypadku typów Double użyj "G17"; w przypadku typów Single użyj ciągu "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

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Jakikolwiek inny pojedynczy znak Nieznany specyfikator Wynik: zgłasza FormatException 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 ponownie Uruchom. 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 metody TryFormat lub przeciążenia metody ToString, która ma parametr format. Poniższy przykład formatuje wartość liczbową jako ciąg waluty w bieżącej kulturze (w tym przypadku kultura en-US).

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

  • Można go podać jako argument formatString 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 = 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 {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ć argument alignment, 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.

    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

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

Poniższe sekcje zawierają szczegółowe informacje o poszczególnych ciągach standardowego formatu liczb.

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 określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności.

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

Specyfikator formatu waluty (C)

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

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

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości NumberFormatInfo, które kontrolują 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, czy właściwość NegativeSign.
NegativeSign Definiuje znak ujemny używany, 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 wartość Double z specyfikatorem 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
//       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

Specyfikator formatu dziesiętnego (D)

Specyfikator formatu D (decimal) 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 określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności. Jeśli nie zostanie określony specyfikator dokładności, wartością domyślną jest wartość minimalna wymagana do przedstawienia wartości całkowitej bez zer wiodących.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. 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 wartość Int32 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

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 w postaci „-d,ddd...E + ddd” lub „-d,ddd...e+ddd”, gdzie każda litera „d” wskazuje cyfrę (0–9). Ciąg rozpoczyna się od znaku minus, jeśli liczba jest ujemna. Zawsze dokładnie jedna cyfra poprzedza punkt dziesiętny.

Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym. Jeśli specyfikator dokładności zostanie pominięty, domyślnie będzie używanych sześć cyfr po punkcie dziesiętnym.

Wielkość liter specyfikatora formatu wskazuje, czy wykładnik potęgi ma być poprzedzany prefiksem „E”, czy „e”. Wykładnik zawsze składa się ze znaku plus lub minus i co najmniej trzech cyfr. W razie potrzeby wykładnik jest dopełniany zerami w celu spełnienia tego minimum.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości NumberFormatInfo, które kontrolują 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 wartość Double z specyfikatorem 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

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 rozpoczyna się od znaku minus, jeśli liczba jest ujemna.

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

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości obiektu NumberFormatInfo, który kontroluje 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 i wartość 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                        

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 określa maksymalną liczbę cyfr znaczących, które mogą być wyświetlane w ciągu wynikowym. Jeżeli specyfikator dokładności zostanie pominięty lub będzie równy zero, typ liczby określa dokładność domyślną, tak jak opisano w poniższej tabeli.

Typ liczbowy Dokładność domyślna
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 stałoprzecinkowa jest używana, jeśli wykładnik, który byłby wynikiem wyrażenia liczby w notacji wykładniczej, jest większy niż -5 i mniejszy niż specyfikator dokładności. W przeciwnym wypadku jest używana notacja wykładnicza. Wynik zawiera punkt dziesiętny, jeśli jest to wymagane, a zera końcowe po punkcie dziesiętnym są pomijane. Jeśli specyfikator dokładności jest obecny i liczba cyfr znaczących w wyniku przekracza określoną dokładność, nadmiarowe cyfry końcowe są usuwane przez zaokrąglenie.

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 wykładnicza, wykładnik w wyniku otrzymuje prefiks „E”, jeśli specyfikatorem formatu jest „G”, lub „e”, jeśli specyfikatorem formatu jest „g”. Wykładnik zawiera co najmniej dwie cyfry. Różni się to od formatu notacji wykładniczej tworzonej przez specyfikator formatu wykładniczego, który obejmuje co najmniej trzy cyfry wykładnika.

W przypadku użycia z wartością Double specyfikator formatu "G17" gwarantuje, że oryginalna wartość Double pomyślnie zaokrągla się. Dzieje się tak, ponieważ Double jest liczbą zmiennoprzecinkową zgodną ze standardem IEEE 754-2008 (binary64), która daje do 17 znaczących cyfr precyzji. W programie .NET Framework zalecamy użycie go zamiast specyfikatora formatu "R" "R", ponieważ w niektórych przypadkach "R" nie może pomyślnie zaokrąglić wartości zmiennoprzecinkowych o podwójnej precyzji.

W przypadku użycia z wartością Single specyfikator formatu "G9" gwarantuje, że oryginalna wartość Single pomyślnie zaokrągla się. Wynika to z faktu, że Single jest liczbą zmiennoprzecinkową zgodną ze standardem IEEE 754-2008 (binary32), która daje do dziewięciu znaczących cyfr precyzji. Ze względu na wydajność zalecamy użycie go zamiast specyfikatora formatu "R".

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości NumberFormatInfo, 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.
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    

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 w postaci „-d ddd ddd,ddd…”, gdzie „-” oznacza w razie potrzeby liczbę ujemną, „d” oznacza cyfrę (0–9), „ ” oznacza separator grupy, a „,” oznacza symbol punktu dziesiętnego. Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym. Jeśli specyfikator dokładności zostanie pominięty, liczba miejsc dziesiętnych jest definiowana przez bieżącą właściwość NumberFormatInfo.NumberDecimalDigits.

Ciąg wynikowy ma wpływ na informacje o formatowaniu bieżącego obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości NumberFormatInfo, które kontrolują 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 właściwość NegativeSign.
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 

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 procentowego („P”) mnoży liczbę przez 100 i konwertuje ją na ciąg, który przedstawia wartość procentową. Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta domyślna precyzja liczbowa dostarczana przez bieżącą właściwość PercentDecimalDigits.

W poniższej tabeli wymieniono właściwości NumberFormatInfo, które kontrolują 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 %

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 typów Half, 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 zaokrąglić wartości Double w niektórych przypadkach. W przypadku wartości Double i Single specyfikator formatu "R" oferuje stosunkowo niską wydajność. Zamiast tego zalecamy użycie specyfikatora formatu "G17" dla wartości Double oraz specyfikatora formatu "G9" w celu pomyślnego Single wartości Single.

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

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 obiektu NumberFormatInfo. W poniższej tabeli wymieniono właściwości NumberFormatInfo, 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.
PositiveSign Definiuje ciąg wskazujący, że wykładnik jest dodatni.

Poniższy przykład formatuje wartość BigInteger z specyfikatorem formatu dwukierunkowego.

#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

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, jeśli są kompilowane przy użyciu przełączników /platform:x64 lub /platform:anycpu i działają 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 powiodło się zaokrąglanie w przypadku kompilowania przy użyciu przełączników /platform:x64 lub /platform:anycpu i uruchamiania 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. Wielkość liter specyfikatora formatu wskazuje, czy w przypadku cyfr szesnastkowych, które są większe niż 9, należy używać wielkich, czy małych liter. Na przykład użycie specyfikatora „X” umożliwia uzyskanie cyfr „ABCDEF”, a specyfikatora „x” — cyfr „abcdef”. Ten format jest obsługiwany tylko w przypadku typów całkowitych.

Specyfikator dokładności określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności.

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

Poniższy przykład formatuje Int32 wartości za pomocą specyfikatora 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

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 Opcje regionalne i językowe elementu w Panelu sterowania wpływają na ciąg wynikowy utworzony przez operację formatowania. Te ustawienia służą do inicjowania obiektu NumberFormatInfo skojarzonego z bieżącą kulturą, który 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 konstruktor CultureInfo(String) jest używany do tworzenia wystąpienia nowego obiektu CultureInfo, który reprezentuje tę samą kulturę co bieżąca kultura systemu, wszelkie dostosowania ustanowione przez Opcje regionalne i językowe elementu w Panelu sterowania zostaną zastosowane do nowego obiektu CultureInfo. Konstruktora CultureInfo(String, Boolean) można użyć do utworzenia obiektu CultureInfo, który nie odzwierciedla dostosowań systemu.

Właściwości NumberFormatInfo

Formatowanie ma wpływ na właściwości bieżącego obiektu NumberFormatInfo, który jest dostarczany niejawnie przez bieżącą kulturę lub jawnie przez parametr IFormatProvider metody, która wywołuje formatowanie. Określ obiekt NumberFormatInfo 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 temat NumberFormatInfo klasy.

Typy liczb całkowitych i zmiennoprzecinkowych

Niektóre opisy specyfikatorów standardowego formatu liczb odnoszą się do całkowitych lub zmiennoprzecinkowych typów liczbowych. Typy liczb całkowitych to Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64i BigInteger. Typy liczb zmiennoprzecinkowe to Decimal, Half, Singlei Double.

Liczba zmiennoprzecinkowa i naN

Niezależnie od ciągu formatu, jeśli wartość Half, Singlelub Double typ zmiennoprzecinkowy jest dodatnią nieskończonością, nieskończonością ujemną lub nie liczbą (NaN), sformatowany ciąg jest wartością odpowiedniego PositiveInfinitySymbol, NegativeInfinitySymbollub NaNSymbol właściwości określonej przez aktualnie odpowiedni obiekt NumberFormatInfo.

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 określonych typów liczbowych (Double i Int32), ale w przypadku dowolnego z innych typów podstawowych liczbowych (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, Halfi 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

Zobacz też