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 postać [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 jest opcjonalną liczbą całkowitą, która wpływa na liczbę cyfr w wynikowym ciągu. W programie .NET 7 i nowszych wersjach maksymalna wartość precyzji to 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 precyzyjnego wyniku. Jeśli istnieją dwa wyniki niemal niemal możliwe do reprezentowania:

    • W przypadku platformy .NET Framework i .NET Core do platformy .NET Core 2.0 środowisko uruchomieniowe wybiera wynik z najmniej znaczącą cyfrą (czyli przy użyciu polecenia MidpointRounding.AwayFromZero).
    • Na platformie .NET Core 2.1 lub nowszej środowisko uruchomieniowe wybiera wynik z co 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 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:

Porada

Możesz pobrać narzędzie formatowania, aplikację platformy .NET Core Windows Forms, która umożliwia stosowanie ciągów formatu do wartości liczbowych lub wartości daty i godziny oraz wyświetlania ciągu wynikowego. 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. Zobacz sekcję Uwagi , aby uzyskać dodatkowe informacje na temat używania standardowych ciągów formatu liczbowego oraz sekcji Przykład kodu , aby zapoznać się z kompleksową ilustracją ich użycia.

Wynik sformatowanego ciągu dla określonej kultury może różnić się 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" Binarne 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 Fixed-Point ("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 kompaktowanie notacji 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)
-> 1,234.0

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

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

-1234.56 ("N3", ru-RU)
-> -1 234,560
„P” 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 Procent ("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” Wartość dwustronna Wynik: ciąg, który można dwustronnie konwertować na identyczny numer.

Obsługiwane przez: Single, Doublei BigInteger.

Uwaga: zalecane tylko dla BigInteger typu. W przypadku Double typów użyj wartości "G17"; w przypadku Single typów 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” Wartość szesnastkowa 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 błąd FormatException w czasie wykonywania.

Używanie standardowych ciągów formatu liczbowego

Uwaga

Przykłady języka C# w tym artykule są uruchamiane 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 pozycję Uruchom . Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub w przypadku niepowodzenia kompilacji okno interaktywne wyświetla 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 na 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 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 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 element formatu jest używany 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 {0:C2}.", value);
// Displays "Your account balance is $123.46."

    Dim value As Decimal = 123.456d
Console.WriteLine("Your account balance is {0:C2}.", value)
' Displays "Your account balance is $123.46."

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

    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 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 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 NumberFormatInfo obiektu.

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 NumberFormatInfo.CurrencyDecimalDigits właściwość .

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 wyniku 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 położenie 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 NegativeSign właściwość.
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 cyfry dziesiętne.
CurrencyGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
CurrencyGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.

Poniższy przykład formatuje Double wartość 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 wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. Jak pokazano w poniższej tabeli, jedna właściwość ma wpływ na formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, ż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

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 wyniku 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, który wskazuje, że liczba jest ujemna zarówno dla współczynnika, jak i wykładnika.
NumberDecimalSeparator Określa ciąg oddzielający cyfry całkowite od cyfr dziesiętnych we współczynniku.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje Double wartość 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 "-ddd.dddd..." 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 NumberFormatInfo.NumberDecimalDigits właściwość dostarcza precyzję liczbową.

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

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, ż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                        

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)

Specyfikator formatu ogólnego ("G") konwertuje liczbę na bardziej kompaktowaną 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 dwukierunkowa liczba cyfr reprezentujących liczbę
Single Najmniejsza zaokrąglona liczba cyfr reprezentujących liczbę (w .NET Framework G7 jest wartością domyślną)
Double Najmniejsza zaokrąglona liczba cyfr reprezentujących liczbę (w .NET Framework wartość domyślna to G15)
Decimal Najmniejsza dwukierunkowa 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 Decimal i specyfikator dokładności zostanie pominięty, jest zawsze używana notacja o stałym punkcie i zera końcowe 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" zapewnia, że oryginalna Double wartość pomyślnie zaokrągla. 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 .NET Framework zalecamy użycie go zamiast specyfikatora formatu "R", ponieważ w niektórych przypadkach "R" nie można pomyślnie zaokrąglić wartości zmiennoprzecinkowych podwójnej precyzji.

W przypadku użycia z wartością Single specyfikator formatu "G9" zapewnia, że oryginalna Single wartość pomyślnie zaokrągla. Jest to spowodowane Single tym, że liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 z jedną precyzją (binary32) daje do dziewięciu znaczących cyfr precyzji. Ze względu na wydajność zalecamy użycie go zamiast specyfikatora formatu "R".

Na ciąg wynikowy mają wpływ 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, który wskazuje, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje różne 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ą NumberFormatInfo.NumberDecimalDigits właściwość.

Na ciąg wynikowy mają wpływ 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, który wskazuje, ż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 liczby całkowitej, które pojawiają się pomiędzy separatorami grup.
NumberGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry 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 różne wartości zmiennoprzecinkowe ze 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ą 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 położenie symbolu procentu dla wartości dodatnich.
PercentNegativePattern Definiuje położenie symbol procentu i symbolu wartości ujemnej dla wartości ujemnych.
NegativeSign Definiuje ciąg, który wskazuje, ż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 cyfry dziesiętne.
PercentGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
PercentGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.

W poniższym przykładzie wartości zmiennoprzecinkowe są formatem 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 rundy (R)

Specyfikator formatu dwukierunkowego ("R") próbuje upewnić się, że wartość liczbowa przekonwertowana na ciąg jest analizowana z powrotem do tej samej wartości liczbowej. Ten format jest obsługiwany tylko w przypadku Halftypów , , SingleDoublei BigInteger .

W .NET Framework i na platformie .NET Core w wersjach starszych niż 3.0 specyfikator formatu "R" w niektórych przypadkach nie może pomyślnie Double zaokrąglić wartości. 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" do pomyślnego zaokrąglenie 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.

Można dodawać specyfikator dokładności, ale jest on ignorowany. W przypadku korzystania z tego specyfikatora konwersje dwustronne mają pierwszeństwo przed dokładnością. Na ciąg wynikowy mają wpływ 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, który wskazuje, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje BigInteger wartość za pomocą specyfikatora 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 w przypadku skompilowania 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 z Double wartościami sformatowanymi przy użyciu standardowego ciągu formatu liczbowego "R" nie powiodło się, jeśli skompilowane przy użyciu /platform:x64 przełączników lub /platform:anycpu i działają 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 jest pomyślnie zaokrąglana, 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("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       .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 NumberFormatInfo obiektu.

Poniższy przykład formatuje wartości za pomocą specyfikatora formatu szesnastkowego Int32 .

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

Uwagi

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

ustawienia Panel sterowania

Ustawienia w elemencie Opcje regionalne i językowe w Panel sterowania wpływają na ciąg wynikowy wygenerowany przez operację formatowania. Te ustawienia są używane do inicjowania NumberFormatInfo obiektu skojarzonego z bieżącą kulturą, która udostępnia wartości używane do zarządzania formatowaniem. Na komputerach, na których są używane różne ustawienia, są generowane różne ciągi wynikowe.

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 Panel 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óre są dostarczane 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 specyfikatorów standardowego formatu liczb odnoszą się do całkowitych lub zmiennoprzecinkowych typów liczbowych. Całkowitoliczbowe typy liczbowe to Byte, , UInt16SByteInt16Int32Int64, UInt32, UInt64, i .BigInteger Typy liczb zmiennoprzecinkowe to Decimal, Half, Singlei Double.

Wartości zmiennoprzecinkowe i NaN

Niezależnie od ciągu formatu, jeśli wartość Halftypu , Singlelub Double zmiennoprzecinkowa jest nieskończonością dodatnią, nieskończonością ujemną, a nie liczbą (NaN), sformatowany ciąg jest wartością odpowiedniego PositiveInfinitySymbolobiektu , NegativeInfinitySymbollub NaNSymbol , która jest określona przez aktualnie odpowiedni NumberFormatInfo obiekt.

Przykładowy kod

W poniższym przykładzie całkowita i zmiennoprzecinkowa wartość liczbowa jest formatowana przy użyciu kultury en-US i wszystkich specyfikatorów standardowego formatu liczb. W tym przykładzie użyto dwóch konkretnych typów liczbowych (Double i ), ale wyniki będą podobne dla dowolnego z innych typów bazowych liczbowych (Byte, SByte, Int64UInt16Int16BigIntegerUInt64UInt32DecimalInt32, Half, i ).SingleInt32

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

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

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

Option Strict On

Imports System.Globalization
Imports System.Threading

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

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

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

Zobacz też