Standardowe ciągi formatujące liczbyStandard Numeric Format Strings

Ciągi standardowych formatów liczb służą do formatowania popularnych typów liczbowych.Standard numeric format strings are used to format common numeric types. Standardowy ciąg formatu liczbowego przyjmuje postać Axx, gdzie:A standard numeric format string takes the form Axx, where:

  • A jest pojedynczym znakiem alfabetycznym o nazwie specyfikator formatu.A is a single alphabetic character called the format specifier. 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.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Aby uzyskać więcej informacji, zobacz Niestandardowe ciągi formatujące.For more information, see Custom Numeric Format Strings.

  • xx jest opcjonalną liczbą całkowitą o nazwie specyfikator dokładności.xx is an optional integer called the precision specifier. Specyfikator dokładności ma zakres od 0 do 99 i wpływa na liczbę cyfr w wyniku.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Należy zauważyć, że specyfikator dokładności określa liczbę cyfr w ciągu reprezentującym liczbę.Note that the precision specifier controls the number of digits in the string representation of a number. Nie zaokrągla samej liczby.It does not round the number itself. Aby wykonać operację zaokrąglania, użyj metody Math.Ceiling, Math.Floorlub Math.Round.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    Gdy specyfikator dokładności kontroluje liczbę ułamków w ciągu wynikowym, ciąg wynikowy odzwierciedla liczbę, która jest zaokrąglana do wyniku, który zostanie zaprezentowany najbliżej nieskończonie precyzyjnego wyniku.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. Jeśli istnieją dwa równie zbliżone wyniki:If there are two equally near representable results:

    • Na .NET Framework i .NET Core do programu .net core 2,0środowisko uruchomieniowe wybiera wynik z bardziej mniejszą cyfrą (czyli przy użyciu MidpointRounding.AwayFromZero).On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using MidpointRounding.AwayFromZero).
    • W przypadku platformy .NET Core 2,1 i nowszychśrodowisko uruchomieniowe wybiera wynik z parzystą cyfrą, która ma co najmniej znaczącą wartość (czyli przy użyciu MidpointRounding.ToEven).On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Uwaga

    Specyfikator dokładności określa liczbę cyfr w ciągu wynikowym.The precision specifier determines the number of digits in the result string. Aby zapełnić ciąg wynikowy początkowymi lub końcowymi spacjami, użyj funkcji formatowania złożonego i zdefiniuj składnik wyrównania w elemencie formatu.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Ciągi standardowego formatu liczbowego są obsługiwane przez:Standard numeric format strings are supported by:

Porada

Możesz pobrać Narzędzie formatowania, aplikację .net Core Windows Forms, która umożliwia stosowanie ciągów formatowania do wartości liczbowych lub daty i godziny i wyświetla ciąg wynikowy.You can download the Formatting Utility, a .NET Core Windows Forms application that lets you apply format strings to either numeric or date and time values and displays the result string. Kod źródłowy jest dostępny dla C# i Visual Basic.Source code is available for C# and Visual Basic.

W poniższej tabeli opisano standardowe specyfikatory formatu liczbowego i przedstawiono przykładowe dane wyjściowe generowane przez każdy specyfikator formatu.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Zapoznaj się z sekcją uwagi , aby uzyskać dodatkowe informacje dotyczące używania ciągów standardowego formatu liczb, oraz sekcję przykładową dla obszernej ilustracji dotyczącej ich używania.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Specyfikator formatuFormat specifier NazwaName OpisDescription PrzykładyExamples
„C” lub „c”"C" or "c" WalutaCurrency Wynik: wartość waluty.Result: A currency value.

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: liczba cyfr dziesiętnych.Precision specifier: Number of decimal digits.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.CurrencyDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Więcej informacji: specyfikator formatu waluty ("C").More information: The Currency ("C") Format Specifier.
123,456 ("C", en-US) — > \$123,46123.456 ("C", en-US) -> \$123.46

123,456 ("C", fr-FR)-> 123, 46 €123.456 ("C", fr-FR) -> 123,46 €

123,456 ("C", ja-JP) — > ¥123123.456 ("C", ja-JP) -> ¥123

-123,456 ("C3", en-US) — > (\$123,456)-123.456 ("C3", en-US) -> (\$123.456)

-123,456 ("C3", fr-FR)->-€123 456-123.456 ("C3", fr-FR) -> -123,456 €

-123,456 ("C3", ja-JP)->-¥123,456-123.456 ("C3", ja-JP) -> -¥123.456
„D” lub „d”"D" or "d" Wartość dziesiętnaDecimal Wynik: liczby całkowite z opcjonalnym znakiem minus.Result: Integer digits with optional negative sign.

Obsługiwane przez: tylko typy całkowite.Supported by: Integral types only.

Specyfikator dokładności: minimalna liczba cyfr.Precision specifier: Minimum number of digits.

Domyślny specyfikator dokładności: minimalna liczba wymaganych cyfr.Default precision specifier: Minimum number of digits required.

Więcej informacji: specyfikator formatu dziesiętnego ("D").More information: The Decimal("D") Format Specifier.
1234 ("D")-> 12341234 ("D") -> 1234

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

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: liczba cyfr dziesiętnych.Precision specifier: Number of decimal digits.

Domyślny specyfikator dokładności: 6.Default precision specifier: 6.

Więcej informacji: specyfikator formatu wykładniczego ("E").More information: The Exponential ("E") Format Specifier.
1052,0329112756 ("E", en-US)-> 1.052033 E + 0031052.0329112756 ("E", en-US) -> 1.052033E+003

1052,0329112756 ("e", fr-FR)-> 1, 052033e + 0031052.0329112756 ("e", fr-FR) -> 1,052033e+003

-1052,0329112756 ("E2", en-US)->-1,05 e + 003-1052.0329112756 ("e2", en-US) -> -1.05e+003

-1052,0329112756 ("E2", fr-FR)->-1, 05E + 003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
„F” lub „f”"F" or "f" Wartość stałoprzecinkowaFixed-point Wynik: cyfry całkowite i dziesiętne z opcjonalnym znakiem minus.Result: Integral and decimal digits with optional negative sign.

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: liczba cyfr dziesiętnych.Precision specifier: Number of decimal digits.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: specyfikator formatu stałego punktu ("F").More information: The Fixed-Point ("F") Format Specifier.
1234,567 ("F", en-US) — > 1234,571234.567 ("F", en-US) -> 1234.57

1234,567 ("F", de-DE)-> 1234, 571234.567 ("F", de-DE) -> 1234,57

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

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

-1234,56 ("F4", en-US)->-1234,5600-1234.56 ("F4", en-US) -> -1234.5600

-1234,56 ("F4", de-DE)->-1234, 1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
„G” lub „g”"G" or "g" OgólneGeneral Wynik: bardziej zwartość notacji stałej lub wykładniczej.Result: The more compact of either fixed-point or scientific notation.

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: liczba cyfr znaczących.Precision specifier: Number of significant digits.

Domyślny specyfikator dokładności: zależy od typu liczbowego.Default precision specifier: Depends on numeric type.

Więcej informacji: specyfikator formatu ogólnego ("G").More information: The General ("G") Format Specifier.
-123,456 ("G", en-US)->-123,456-123.456 ("G", en-US) -> -123.456

-123,456 ("G", SV-SE)->-123 456-123.456 ("G", sv-SE) -> -123,456

123,4546 ("G4", en-US) — > 123,5123.4546 ("G4", en-US) -> 123.5

123,4546 ("G4", SV-SE)-> 123, 5123.4546 ("G4", sv-SE) -> 123,5

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

-1.234567890 e-25 ("G", SV-SE)->-1, 23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
„N” lub „n”"N" or "n" Wartość liczbowaNumber Wynik: cyfry całkowite i dziesiętne, separatory grup i separator dziesiętny z opcjonalnym znaku minus.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: wymagana liczba miejsc dziesiętnych.Precision specifier: Desired number of decimal places.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: specyfikator formatu liczbowego ("N").More information: The Numeric ("N") Format Specifier.
1234,567 ("N", en-US) — > 1 234,571234.567 ("N", en-US) -> 1,234.57

1234,567 ("N", ru-RU) — > 1 234, 571234.567 ("N", ru-RU) -> 1 234,57

1234 ("N1", en-US) — > 1 234,01234 ("N1", en-US) -> 1,234.0

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

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

-1234,56 ("N3", ru-RU)->-1 234 560-1234.56 ("N3", ru-RU) -> -1 234,560
„P” lub „p”"P" or "p" Wartość procentowaPercent Wynik: liczba pomnożona przez 100 i wyświetlana z symbolem procentu.Result: Number multiplied by 100 and displayed with a percent symbol.

Obsługiwany przez: wszystkie typy liczbowe.Supported by: All numeric types.

Specyfikator dokładności: wymagana liczba miejsc dziesiętnych.Precision specifier: Desired number of decimal places.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.PercentDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Więcej informacji: specyfikator formatu procentowego ("P").More information: The Percent ("P") Format Specifier.
1 ("P", en-US)-> 100,00%1 ("P", en-US) -> 100.00 %

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

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

-0,39678 ("P1", fr-FR)->-39, 7%-0.39678 ("P1", fr-FR) -> -39,7 %
„R” lub „r”"R" or "r" Wartość dwustronnaRound-trip Wynik: ciąg, który można dwustronnie konwertować na identyczny numer.Result: A string that can round-trip to an identical number.

Obsługiwane przez: Single, Doublei BigInteger.Supported by: Single, Double, and BigInteger.

Uwaga: zalecane tylko dla BigInteger typu.Note: Recommended for the BigInteger type only. W przypadku typów Double Użyj "G17"; w przypadku typów Single Użyj "G9".For Double types, use "G17"; for Single types, use "G9".
Specyfikator dokładności: ignorowany.Precision specifier: Ignored.

Więcej informacji: specyfikator formatu rundying ("R").More information: The Round-trip ("R") Format Specifier.
123456789,12345678 ("R") — > 123456789,12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890,12345678 ("R")->-1234567890,1234567-1234567890.12345678 ("R") -> -1234567890.1234567
„X” lub „x”"X" or "x" Wartość szesnastkowaHexadecimal Wynik: ciąg szesnastkowy.Result: A hexadecimal string.

Obsługiwane przez: tylko typy całkowite.Supported by: Integral types only.

Specyfikator dokładności: liczba cyfr w ciągu wynikowym.Precision specifier: Number of digits in the result string.

Więcej informacji: specyfikator formatu szesnastkowego ("X").More information: The HexaDecimal ("X") Format Specifier.
255 ("X") — > FF255 ("X") -> FF

-1 ("x")-> FF-1 ("x") -> ff

255 ("X4") — > 00ff255 ("x4") -> 00ff

-1 ("X4")-> 00FF-1 ("X4") -> 00FF
Jakikolwiek inny pojedynczy znakAny other single character Nieznany specyfikatorUnknown specifier Wynik: zgłasza FormatException w czasie wykonywania.Result: Throws a FormatException at run time.

Korzystając ze standardowego, numerycznego ciągu formatującegoUsing Standard Numeric Format Strings

Uwaga

Przykłady języka C#, w tym artykule są uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.The C# examples in this article run in the Try.NET inline code runner and playground. Wybierz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.Select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Ciąg standardowego formatu liczb może służyć do definiowania formatowania wartości liczbowej na jeden z dwóch sposobów:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Można go przesłać do przeciążenia metody ToString, która ma parametr format.It can be passed to an overload of the ToString method that has a format parameter. Poniższy przykład formatuje wartość liczbową jako ciąg waluty w bieżącej kulturze (w tym przypadku kultury en-US).The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    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 ją podać jako argument formatString w elemencie formatu używanym z takimi metodami jak String.Format, Console.WriteLinei StringBuilder.AppendFormat.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Aby uzyskać więcej informacji, zobacz formatowanie złożone.For more information, see Composite Formatting. W poniższym przykładzie element formatu jest używany do wstawienia wartości waluty w ciągu.The following example uses a format item to insert a currency value in a string.

    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ć argument alignment, aby określić szerokość pola liczbowego i czy jego wartość jest wyrównana do prawej lub do lewej.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. Poniższy przykład umożliwia wyrównanie wartości walutowej w 28-znakowym polu i wyrównanie wartości walutowej do pola 14 znaków.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    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że być dostarczony jako argument formatString w elemencie wyrażenia interpolowanego ciągu interpolowanego.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Aby uzyskać więcej informacji, zobacz temat Interpolacja ciągów w temacie C# Reference lub interpolowanych ciągów w odwołaniu Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

Poniższe sekcje zawierają szczegółowe informacje o poszczególnych ciągach standardowego formatu liczb.The following sections provide detailed information about each of the standard numeric format strings.

Specyfikator formatu waluty („C”)The Currency ("C") Format Specifier

Specyfikator formatu C (currency) konwertuje liczbę na ciąg przedstawiający kwotę w walucie.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych w wynikowym ciągu.The precision specifier indicates the desired number of decimal places in the result string. Jeśli specyfikator dokładności zostanie pominięty, domyślna precyzja jest definiowana przez właściwość NumberFormatInfo.CurrencyDecimalDigits.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

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.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. 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.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie zwracanego ciągu.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
CurrencyPositivePattern Definiuje położenie symbolu waluty dla wartości dodatnich.Defines the placement of the currency symbol for positive values.
CurrencyNegativePattern Definiuje położenie symbolu waluty dla wartości ujemnych i określa, czy znak minus jest reprezentowany przez nawiasy, czy właściwość NegativeSign.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Definiuje znak ujemny używany, jeśli CurrencyNegativePattern wskazuje, że nawiasy nie są używane.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Definiuje symbol waluty.Defines the currency symbol.
CurrencyDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości waluty.Defines the default number of decimal digits in a currency value. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.Defines the number of integer digits that appear in a group.

Poniższy przykład formatuje wartość Double przy użyciu specyfikatora formatu waluty:The following example formats a Double value with the currency format specifier:

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

Wróć do tabeliBack to table

Specyfikator formatu dziesiętnego („D”)The Decimal ("D") Format Specifier

Specyfikator formatu D (decimal) konwertuje liczbę na ciąg cyfr dziesiętnych (0–9), poprzedzony znakiem minus, jeśli liczba jest ujemna.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Ten format jest obsługiwany tylko w przypadku typów całkowitych.This format is supported only for integral types.

Specyfikator dokładności określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym.The precision specifier indicates the minimum number of digits desired in the resulting string. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. 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.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Jak pokazano w poniższej tabeli, jedna właściwość ma wpływ na formatowanie ciągu wynikowego.As the following table shows, a single property affects the formatting of the result string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.

Poniższy przykład formatuje wartość Int32 przy użyciu specyfikatora formatu dziesiętnego.The following example formats an Int32 value with the decimal format specifier.

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

Wróć do tabeliBack to table

Specyfikator formatu wykładniczego („E”)The Exponential ("E") Format Specifier

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).The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). Ciąg rozpoczyna się od znaku minus, jeśli liczba jest ujemna.The string starts with a minus sign if the number is negative. Zawsze dokładnie jedna cyfra poprzedza punkt dziesiętny.Exactly one digit always precedes the decimal point.

Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym.The precision specifier indicates the desired number of digits after the decimal point. Jeśli specyfikator dokładności zostanie pominięty, domyślnie będzie używanych sześć cyfr po punkcie dziesiętnym.If the precision specifier is omitted, a default of six digits after the decimal point is used.

Wielkość liter specyfikatora formatu wskazuje, czy wykładnik potęgi ma być poprzedzany prefiksem „E”, czy „e”.The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". Wykładnik zawsze składa się ze znaku plus lub minus i co najmniej trzech cyfr.The exponent always consists of a plus or minus sign and a minimum of three digits. W razie potrzeby wykładnik jest dopełniany zerami w celu spełnienia tego minimum.The exponent is padded with zeros to meet this minimum, if required.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie zwracanego ciągu.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna zarówno dla współczynnika, jak i wykładnika.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Określa ciąg oddzielający cyfry całkowite od cyfr dziesiętnych we współczynniku.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.Defines the string that indicates that an exponent is positive.

Poniższy przykład formatuje wartość Double przy użyciu specyfikatora formatu wykładniczego:The following example formats a Double value with the exponential format specifier:

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

Wróć do tabeliBack to table

Specyfikator formatu stałoprzecinkowego („F”)The Fixed-Point ("F") Format Specifier

Specyfikator formatu stałego ("F") konwertuje liczbę na ciąg w postaci "-. DDD..." gdzie każda litera "d" wskazuje cyfrę (0-9).The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). Ciąg rozpoczyna się od znaku minus, jeśli liczba jest ujemna.The string starts with a minus sign if the number is negative.

Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych.The precision specifier indicates the desired number of decimal places. Jeśli specyfikator dokładności zostanie pominięty, bieżąca Właściwość NumberFormatInfo.NumberDecimalDigits dostarcza precyzji liczbowej.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości obiektu NumberFormatInfo, które kontrolują formatowanie ciągu wynikowego.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych.Defines the default number of decimal digits. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.This value can be overridden by using the precision specifier.

Poniższy przykład formatuje Double i Int32 wartość przy użyciu specyfikatora formatu ustalonego:The following example formats a Double and an Int32 value with the fixed-point format specifier:

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                        

Wróć do tabeliBack to table

Specyfikator formatu ogólnego („G”)The General ("G") Format Specifier

Specyfikator formatu ogólnego ("G") konwertuje liczbę na bardziej zwartą notacji stałej lub wykładniczej, w zależności od typu liczby i tego, czy jest obecny Specyfikator dokładności.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. Specyfikator dokładności określa maksymalną liczbę cyfr znaczących, które mogą być wyświetlane w ciągu wynikowym.The precision specifier defines the maximum number of significant digits that can appear in the result string. 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.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Typ liczbowyNumeric type Dokładność domyślnaDefault precision
Byte lub SByteByte or SByte 3 cyfry3 digits
Int16 lub UInt16Int16 or UInt16 5 cyfr5 digits
Int32 lub UInt32Int32 or UInt32 10 cyfr10 digits
Int64 19 cyfr19 digits
UInt64 20 cyfr20 digits
BigInteger Bez ograniczeń (analogicznie jak "R")Unlimited (same as "R")
Single 7 cyfr7 digits
Double 15 cyfr15 digits
Decimal 29 cyfr29 digits

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.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. Wynik zawiera punkt dziesiętny, jeśli jest to wymagane, a zera końcowe po punkcie dziesiętnym są pomijane.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. 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.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

Jeśli jednak liczba jest Decimal a specyfikator dokładności zostanie pominięty, notacja stałego punktu jest zawsze używana i końcowe zera są zachowywane.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

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”.If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". Wykładnik zawiera co najmniej dwie cyfry.The exponent contains a minimum of two digits. Różni się to od formatu notacji wykładniczej tworzonej przez specyfikator formatu wykładniczego, który obejmuje co najmniej trzy cyfry wykładnika.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Należy pamiętać, że w przypadku użycia z wartością Double specyfikator formatu "G17" gwarantuje, że oryginalna Double wartość została pomyślnie przebłądzenia.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Wynika to z faktu, że Double to liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 (binary64), która oferuje maksymalnie 17 cyfr znaczących dokładności.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Zaleca się używanie zamiast specyfikatora formatu "r", ponieważ w niektórych przypadkach "r" nie powiodło się pomyślnie rundy wartości zmiennoprzecinkowych podwójnej precyzji.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. Poniższy przykład ilustruje jeden przypadek.The following example illustrates one such case.

double original = 0.84551240822557006;
var rSpecifier = original.ToString("R");
var g17Specifier = original.ToString("G17");

var rValue = Double.Parse(rSpecifier);
var g17Value = Double.Parse(g17Specifier);

Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

W przypadku użycia z wartością Single specyfikator formatu "G9" gwarantuje, że oryginalna Single wartość została pomyślnie przerundna.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Dzieje się tak, ponieważ Single jest liczba zmiennoprzecinkowa o pojedynczej precyzji zgodnej z IEEE 754-2008 (binary32), która daje maksymalnie dziewięć znaczących cyfr dokładności.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Ze względu na wydajność zaleca się użycie zamiast specyfikatora formatu "R".For performance reasons, we recommend its use instead of the "R" format specifier.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie ciągu wynikowego.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.Defines the string that separates integral digits from decimal digits.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.Defines the string that indicates that an exponent is positive.

Poniższy przykład formatuje różne wartości zmiennoprzecinkowe przy użyciu specyfikatora formatu ogólnego:The following example formats assorted floating-point values with the general format specifier:

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    

Wróć do tabeliBack to table

Specyfikator formatu numerycznego („N”)The Numeric ("N") Format Specifier

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.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym.The precision specifier indicates the desired number of digits after the decimal point. Jeśli specyfikator dokładności zostanie pominięty, Liczba miejsc dziesiętnych jest definiowana przez bieżącą Właściwość NumberFormatInfo.NumberDecimalDigits.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie ciągu wynikowego.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.
NumberNegativePattern Definiuje format wartości ujemnych i określa, czy znak minus jest reprezentowany przez nawiasy, czy właściwość NegativeSign.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się pomiędzy separatorami grup.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych.Defines the default number of decimal digits. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.This value can be overridden by using a precision specifier.

Poniższy przykład formatuje różne wartości zmiennoprzecinkowe przy użyciu specyfikatora formatu liczb:The following example formats assorted floating-point values with the number format specifier:

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 

Wróć do tabeliBack to table

Specyfikator formatu procenta („P”)The Percent ("P") Format Specifier

Specyfikator formatu procentowego („P”) mnoży liczbę przez 100 i konwertuje ją na ciąg, który przedstawia wartość procentową.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych.The precision specifier indicates the desired number of decimal places. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta Domyślna precyzja liczbowa podana przez bieżącą Właściwość PercentDecimalDigits.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie zwracanego ciągu.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
PercentPositivePattern Definiuje położenie symbolu procentu dla wartości dodatnich.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Definiuje położenie symbol procentu i symbolu wartości ujemnej dla wartości ujemnych.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.
PercentSymbol Definiuje symbol procentu.Defines the percent symbol.
PercentDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości procentowej.Defines the default number of decimal digits in a percentage value. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.Defines the string that separates groups of integral numbers.
PercentGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.Defines the number of integer digits that appear in a group.

W poniższym przykładzie wartości zmiennoprzecinkowe są formatowane przy użyciu specyfikatora formatu wartości procentowej:The following example formats floating-point values with the percent format specifier:

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 %

Wróć do tabeliBack to table

Specyfikator formatu obustronnej konwersji („R”)The Round-trip ("R") Format Specifier

Specyfikator formatu rundy ("R") próbuje upewnić się, że wartość liczbowa, która jest konwertowana na ciąg, zostanie przeanalizowana z powrotem na taką samą wartość liczbową.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Ten format jest obsługiwany tylko w przypadku typów Single, Doublei BigInteger.This format is supported only for the Single, Double, and BigInteger types.

W przypadku wartości Double specyfikator formatu "R" w niektórych przypadkach nie może pomyślnie wykonać rundy pierwotnej wartości.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. W przypadku wartości Double i Single oferuje również stosunkowo niską wydajność.For both Double and Single values, it also offers relatively poor performance. Zamiast tego zalecamy użycie specyfikatora formatu "G17" dla wartości Double i specyfikatora formatu "G9" , aby pomyślnie zaokrąglić Single wartości.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Gdy wartość BigInteger jest sformatowana przy użyciu tego specyfikatora, jego reprezentacja w postaci ciągu zawiera wszystkie cyfry znaczące w BigInteger wartości.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Można dodawać specyfikator dokładności, ale jest on ignorowany.Although you can include a precision specifier, it is ignored. W przypadku korzystania z tego specyfikatora konwersje dwustronne mają pierwszeństwo przed dokładnością.Round trips are given precedence over precision when using this specifier. Informacje o formatowaniu bieżącego obiektu NumberFormatInfo mają wpływ na ciąg wynikowy.The result string is affected by the formatting information of the current NumberFormatInfo object. Poniższa tabela zawiera listę właściwości NumberFormatInfo, które kontrolują formatowanie ciągu wynikowego.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Właściwość NumberFormatInfoNumberFormatInfo property OpisDescription
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.Defines the string that separates integral digits from decimal digits.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.Defines the string that indicates that an exponent is positive.

Poniższy przykład formatuje wartość BigInteger przy użyciu specyfikatora formatu okrężnego.The following example formats a BigInteger value with the round-trip format specifier.

#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 przeprowadzono pomyślnie rundy w przypadku skompilowania za pomocą /platform:x64 lub /platform:anycpu przełączników i uruchamiania w systemach 64-bitowych.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Więcej informacji można znaleźć w poniższym akapicie.See the following paragraph for more information.

Aby obejść problem Double wartości sformatowane przy użyciu standardowego ciągu formatu liczbowego "R", który nie został pomyślnie zaokrąglony, w przypadku skompilowania za pomocą przełączników /platform:x64 lub /platform:anycpu i uruchamiania w systemach 64-bitowych. można sformatować Double wartości przy użyciu "G17" ciąg standardowego formatu liczbowego.To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. Poniższy przykład używa ciągu formatu "R" z wartością Double, która nie jest pomyślna, a także używa ciągu formatu "G17", aby pomyślnie zaokrąglić oryginalną wartość:The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True
Imports System.Globalization

Module Example
   Public Sub Main()
      Console.WriteLine("Attempting to round-trip a Double with 'R':")
      Dim initialValue As Double = 0.6822871999174
      Dim valueString As String = initialValue.ToString("R",
                                               CultureInfo.InvariantCulture)
      Dim roundTripped As Double = Double.Parse(valueString,
                                                CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped, initialValue.Equals(roundTripped))
      Console.WriteLine()
      
      Console.WriteLine("Attempting to round-trip a Double with 'G17':")
      Dim valueString17 As String = initialValue.ToString("G17",
                                                 CultureInfo.InvariantCulture)
      Dim roundTripped17 As Double = double.Parse(valueString17,
                                            CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17))
   End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Wróć do tabeliBack to table

Specyfikator formatu szesnastkowego („X”)The Hexadecimal ("X") Format Specifier

Specyfikator formatu szesnastkowego („X”) konwertuje liczbę na ciąg cyfr szesnastkowych.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. 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.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Na przykład użycie specyfikatora „X” umożliwia uzyskanie cyfr „ABCDEF”, a specyfikatora „x” — cyfr „abcdef”.For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Ten format jest obsługiwany tylko w przypadku typów całkowitych.This format is supported only for integral types.

Specyfikator dokładności określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym.The precision specifier indicates the minimum number of digits desired in the resulting string. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

Informacje o formatowaniu bieżącego obiektu NumberFormatInfo nie wpływają na ciąg wynikowy.The result string is not affected by the formatting information of the current NumberFormatInfo object.

Poniższy przykład formatuje Int32 wartości ze specyfikatorem formatu szesnastkowego.The following example formats Int32 values with the hexadecimal format specifier.

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

Wróć do tabeliBack to table

UwagiNotes

Ustawienia panelu sterowaniaControl Panel Settings

Ustawienia w elemencie Opcje regionalne i językowe w panelu sterowania wpływają na ciąg wynikowy generowany przez operację formatowania.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Te ustawienia są używane do inicjowania obiektu NumberFormatInfo skojarzonego z bieżącą kulturą wątku, która zapewnia wartości używane do zarządzania formatowaniem.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Na komputerach, na których są używane różne ustawienia, są generowane różne ciągi wynikowe.Computers that use different settings generate different result strings.

Ponadto, jeśli Konstruktor CultureInfo.CultureInfo(String) jest używany do utworzenia wystąpienia nowego obiektu CultureInfo, który reprezentuje tę samą kulturę co bieżąca kultura systemu, wszelkie dostosowania ustanowione przez element Opcje regionalne i językowe w panelu sterowania będą zastosowano do nowego obiektu CultureInfo.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. Można użyć konstruktora CultureInfo.CultureInfo(String, Boolean), aby utworzyć obiekt CultureInfo, który nie odzwierciedla dostosowań systemu.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Właściwości klasy NumberFormatInfoNumberFormatInfo Properties

Na formatowanie mają wpływ właściwości bieżącego obiektu NumberFormatInfo, który jest dostarczany niejawnie przez bieżącą kulturę wątku lub jawnie przez parametr IFormatProvider metody, która wywołuje formatowanie.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Określ NumberFormatInfo lub obiekt CultureInfo dla tego parametru.Specify a NumberFormatInfo or CultureInfo object for that parameter.

Uwaga

Aby uzyskać informacje na temat dostosowywania wzorców lub ciągów używanych w formatowaniu wartości liczbowych, zobacz temat Klasa NumberFormatInfo.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Całkowite i zmiennoprzecinkowe rodzaje wartości numerycznychIntegral and Floating-Point Numeric Types

Niektóre opisy specyfikatorów standardowego formatu liczb odnoszą się do całkowitych lub zmiennoprzecinkowych typów liczbowych.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Całkowite typy liczbowe to Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64i BigInteger.The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Typy liczbowe zmiennoprzecinkowe to Decimal, Singlei Double.The floating-point numeric types are Decimal, Single, and Double.

Zmiennoprzecinkowe nieskończoności i NaNFloating-Point Infinities and NaN

Niezależnie od ciągu formatu, jeśli wartość Single lub Double typu zmiennoprzecinkowego jest nieskończoności dodatniej, nieskończoności ujemnej lub nie jest liczbą (NaN), sformatowany ciąg jest wartością odpowiedniej właściwości PositiveInfinitySymbol, NegativeInfinitySymbollub NaNSymbol określone przez aktualnie stosowany obiekt NumberFormatInfo.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

PrzykładExample

Uwaga

Przykłady języka C#, w tym artykule uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Wybierz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.Select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

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.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. W tym przykładzie zastosowano dwa określone typy liczbowe (Double i Int32), ale byłyby wyniki podobne dla dowolnego z pozostałych liczbowych typów podstawowych (Byte, SByte, Int16, Int32, Int64, UInt16UInt32, UInt64, BigInteger, Decimali Single).This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and 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: {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 takżeSee also