Строки настраиваемых числовых форматовCustom numeric format strings

Чтобы определить способ форматирования числовых данных, можно создать строку настраиваемого числового формата, состоящую из одного или нескольких описателей настраиваемого формата.You can create a custom numeric format string, which consists of one or more custom numeric specifiers, to define how to format numeric data. Строка настраиваемого числового формата — это любая строка формата, не являющаяся строкой стандартного числового формата.A custom numeric format string is any format string that is not a standard numeric format string.

Строки настраиваемых числовых форматов поддерживаются некоторыми перегрузками метода ToString всех числовых типов.Custom numeric format strings are supported by some overloads of the ToString method of all numeric types. Например, можно задать строку числового формата для методов ToString(String) и ToString(String, IFormatProvider) типа Int32 .For example, you can supply a numeric format string to the ToString(String) and ToString(String, IFormatProvider) methods of the Int32 type. Строки настраиваемых числовых форматов также поддерживаются функцией составного форматирования .NET Framework, используемой некоторыми методами Write и WriteLine классов Console и StreamWriter, а также методами String.Format и StringBuilder.AppendFormat.Custom numeric format strings are also supported by the .NET composite formatting feature, which is used by some Write and WriteLine methods of the Console and StreamWriter classes, the String.Format method, and the StringBuilder.AppendFormat method. Функция интерполяции строк также поддерживает строки настраиваемого числового формата.String interpolation feature also supports custom numeric format strings.

Совет

Вы можете загрузить Служебную программу форматирования, которая применяет строки формата к значениям даты и времени или числовым значениям и отображает результирующую строку.You can download the Formatting Utility, an application that enables you to apply format strings to either numeric or date and time values and displays the result string.

В следующей таблице приведены описатели стандартного числового формата и примеры выходных данных, формируемых каждым описателем формата.The following table describes the custom numeric format specifiers and displays sample output produced by each format specifier. Дополнительные сведения об использовании строк настраиваемого числового формата см. в разделе Примечания ; обширную демонстрацию их использования см. в разделе Пример .See the Notes section for additional information about using custom numeric format strings, and the Example section for a comprehensive illustration of their use.

Описатель форматаFormat specifier nameName Описание:Description ПримерыExamples
"0""0" Знак-заместитель нуляZero placeholder Заменяет ноль соответствующей цифрой, если такая имеется. В противном случае в результирующей строке будет стоять ноль.Replaces the zero with the corresponding digit if one is present; otherwise, zero appears in the result string.

Дополнительные сведения: Настраиваемый описатель "0".More information: The "0" Custom Specifier.
1234.5678 ("00000") -> 012351234.5678 ("00000") -> 01235

0.45678 ("0.00", en-US) -> 0.460.45678 ("0.00", en-US) -> 0.46

0.45678 ("0.00", fr-FR) -> 0,460.45678 ("0.00", fr-FR) -> 0,46
"#""#" Заместитель цифрыDigit placeholder Заменяет знак "#" соответствующей цифрой, если такая имеется. В противном случае в результирующей строке не будет цифры.Replaces the "#" symbol with the corresponding digit if one is present; otherwise, no digit appears in the result string.

Обратите внимание, что в итоговой строке не будет отображаться цифра, если соответствующей цифрой в строке ввода является незначащий 0.Note that no digit appears in the result string if the corresponding digit in the input string is a non-significant 0. Например, 0003 ("####") -> 3.For example, 0003 ("####") -> 3.

Дополнительные сведения: Настраиваемый описатель "#".More information: The "#" Custom Specifier.
1234.5678 ("#####") -> 12351234.5678 ("#####") -> 1235

0.45678 ("#.##", en-US) -> .460.45678 ("#.##", en-US) -> .46

0.45678 ("#.##", fr-FR) -> ,460.45678 ("#.##", fr-FR) -> ,46
".""." РазделительDecimal point Определяет расположение разделителя целой и дробной частей в результирующей строке.Determines the location of the decimal separator in the result string.

Дополнительные сведения см. в разделе Настраиваемый описатель ".".More information: The "." Custom Specifier.
0.45678 ("0.00", en-US) -> 0.460.45678 ("0.00", en-US) -> 0.46

0.45678 ("0.00", fr-FR) -> 0,460.45678 ("0.00", fr-FR) -> 0,46
",""," Разделитель групп и масштабирование чиселGroup separator and number scaling Служит в качестве описателя разделителя групп и описателя масштабирования чисел.Serves as both a group separator and a number scaling specifier. В качестве разделителя групп вставляет локализованный символ-разделитель групп между всеми группами.As a group separator, it inserts a localized group separator character between each group. В качестве описателя масштабирования чисел делит число на 1000 для всех указанных запятых.As a number scaling specifier, it divides a number by 1000 for each comma specified.

Дополнительные сведения: Настраиваемый описатель ",".More information: The "," Custom Specifier.
Описатель разделителя групп:Group separator specifier:

2147483647 ("##,#", en-US) -> 2,147,483,6472147483647 ("##,#", en-US) -> 2,147,483,647

2147483647 ("##,#", es-ES) -> 2.147.483.6472147483647 ("##,#", es-ES) -> 2.147.483.647

Описатель масштабирования:Scaling specifier:

2147483647 ("#,#,,", en-US) -> 2,1472147483647 ("#,#,,", en-US) -> 2,147

2147483647 ("#,#,,", es-ES) -> 2.1472147483647 ("#,#,,", es-ES) -> 2.147
"%""%" Заместитель процентовPercentage placeholder Умножает число на 100 и вставляет локализованный символ процента в результирующую строку.Multiplies a number by 100 and inserts a localized percentage symbol in the result string.

Дополнительные сведения: Настраиваемый описатель "%".More information: The "%" Custom Specifier.
0.3697 ("%#0.00", en-US) -> %36.970.3697 ("%#0.00", en-US) -> %36.97

0.3697 ("%#0.00", el-GR) -> %36,970.3697 ("%#0.00", el-GR) -> %36,97

0.3697 ("##.0 %", en-US) -> 37.0 %0.3697 ("##.0 %", en-US) -> 37.0 %

0.3697 ("##.0 %", el-GR) -> 37,0 %0.3697 ("##.0 %", el-GR) -> 37,0 %
"‰""‰" Местозаполнитель промиллеPer mille placeholder Умножает число на 1000 и вставляет локализованный символ промилле в результирующую строку.Multiplies a number by 1000 and inserts a localized per mille symbol in the result string.

Дополнительные сведения: Настраиваемый описатель "‰".More information: The "‰" Custom Specifier.
0.03697 ("#0.00‰", en-US) -> 36.97‰0.03697 ("#0.00‰", en-US) -> 36.97‰

0.03697 ("#0.00‰", ru-RU) -> 36,97‰0.03697 ("#0.00‰", ru-RU) -> 36,97‰
"E0""E0"

"E+0""E+0"

"E-0""E-0"

"E0""e0"

"E+0""e+0"

"E-0""e-0"
Экспоненциальная нотацияExponential notation Если за этим описателем следует по меньшей мере один ноль (0), результат форматируется с использованием экспоненциальной нотации.If followed by at least one 0 (zero), formats the result using exponential notation. Регистр ("E" или "e") определяет регистр символа экспоненты в результирующей строке.The case of "E" or "e" indicates the case of the exponent symbol in the result string. Минимальное число цифр экспоненты определяется количеством нулей, стоящих за символом "E" или "e".The number of zeros following the "E" or "e" character determines the minimum number of digits in the exponent. Знак "+" указывает на то, что перед экспонентой всегда должен ставиться символ знака.A plus sign (+) indicates that a sign character always precedes the exponent. Знак "-" указывает на то, что символ знака должен ставиться только в случае, если экспонента имеет отрицательное значение.A minus sign (-) indicates that a sign character precedes only negative exponents.

Дополнительные сведения: Настраиваемые описатели "E" и "e".More information: The "E" and "e" Custom Specifiers.
987654 ("#0.0e0") -> 98.8e4987654 ("#0.0e0") -> 98.8e4

1503.92311 ("0.0##e+00") -> 1.504e+031503.92311 ("0.0##e+00") -> 1.504e+03

1.8901385E-16 ("0.0e+00") -> 1.9e-161.8901385E-16 ("0.0e+00") -> 1.9e-16
"\""\" Escape-символEscape character Указывает на то, что следующий за ним символ должен рассматриваться как литерал, а не как описатель настраиваемого формата.Causes the next character to be interpreted as a literal rather than as a custom format specifier.

Дополнительные сведения: Escape-символ \.More information: The "\" Escape Character.
987654 ("\###00\#") -> #987654#987654 ("\###00\#") -> #987654#
'строка''string'

"строка""string"
Разделитель строк-литераловLiteral string delimiter Указывает на то, что заключенные в разделители символы должны быть скопированы в результирующую строку без изменений.Indicates that the enclosed characters should be copied to the result string unchanged.

Дополнительные сведения см. в подразделе Символьные литералы.More information: Character literals.
68 ("# ' градусов'") -> 68 градусов68 ("# ' degrees'") -> 68 degrees

68 ("# ' градусов'") -> 68 градусов68 ("#' degrees'") -> 68 degrees
;; Разделитель секцийSection separator Определяет секции с раздельными строками формата для положительных чисел, отрицательных чисел и нуля.Defines sections with separate format strings for positive, negative, and zero numbers.

Дополнительные сведения: Разделитель секций ";".More information: The ";" Section Separator.
12.345 ("#0.0#;(#0.0#);-\0-") -> 12.3512.345 ("#0.0#;(#0.0#);-\0-") -> 12.35

0 ("#0.0#;(#0.0#);-\0-") -> -0-0 ("#0.0#;(#0.0#);-\0-") -> -0-

-12.345 ("#0.0#;(#0.0#);-\0-") -> (12.35)-12.345 ("#0.0#;(#0.0#);-\0-") -> (12.35)

12.345 ("#0.0#;(#0.0#)") -> 12.3512.345 ("#0.0#;(#0.0#)") -> 12.35

0 ("#0.0#;(#0.0#)") -> 0.00 ("#0.0#;(#0.0#)") -> 0.0

-12.345 ("#0.0#;(#0.0#)") -> (12.35)-12.345 ("#0.0#;(#0.0#)") -> (12.35)
ДругойOther Все остальные символыAll other characters Символ копируется в результирующую строку без изменений.The character is copied to the result string unchanged.

Дополнительные сведения см. в подразделе Символьные литералы.More information: Character literals.
68 ("# °") -> 68 °68 ("# °") -> 68 °

В приведенных ниже разделах содержится подробная информация о всех описателях настраиваемого числового формата.The following sections provide detailed information about each of the custom numeric format specifiers.

Примечание

The C# examples in this article run in the Try.NET inline code runner and playground. Select the Run button to run an example in an interactive window. Once you execute the code, you can modify it and run the modified code by selecting Run again. The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

The current culture of the Try.NET inline code runner and playground is the invariant culture. As a result, the output produced by the inline code runner differs from the output displayed by examples that use a default culture as the current culture.

You can work around this limitation by adding a line of code like the following to set the culture: System.Globalization.CultureInfo.CurrentCulture = new System.Globalization.CultureInfo("en-US"); Just replace en-US with the name of the culture that you'd like to be the current culture.

Настраиваемый описатель "0"The "0" custom specifier

Описатель настраиваемого формата "0" служит нулевым символом-заполнителем.The "0" custom format specifier serves as a zero-placeholder symbol. Если форматируемое значение содержит цифру в позиции, где в строке формата стоит ноль, то эта цифра копируется в результирующую строку; в противном случае в результирующей строке будет стоять ноль.If the value that is being formatted has a digit in the position where the zero appears in the format string, that digit is copied to the result string; otherwise, a zero appears in the result string. Позиция крайнего левого нуля перед разделителем целой и дробной частей и позиция крайнего правого нуля после разделителя целой и дробной частей определяют диапазон цифр, которые всегда включаются в результирующую строку.The position of the leftmost zero before the decimal point and the rightmost zero after the decimal point determines the range of digits that are always present in the result string.

Спецификатор "00" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичной точке-разделителю, если назначено использование округления от нуля.The "00" specifier causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. Например, в результате форматирования числа 34,5 с помощью строки "00" будет получена строка со значением"35".For example, formatting 34.5 with "00" would result in the value 35.

В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих нулевые заполнители.The following example displays several values that are formatted by using custom format strings that include zero placeholders.

double value;

value = 123;
Console::WriteLine(value.ToString("00000"));
Console::WriteLine(String::Format("{0:00000}", value));
// Displays 00123

value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                  "{0:0.00}", value));
// Displays 1.20

Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:00.00}", value));
// Displays 01.20

CultureInfo^ daDK = CultureInfo::CreateSpecificCulture("da-DK");
Console::WriteLine(value.ToString("00.00", daDK)); 
Console::WriteLine(String::Format(daDK, "{0:00.00}", value));
// Displays 01,20

value = .56;
Console::WriteLine(value.ToString("0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.0}", value));
// Displays 0.6

value = 1234567890;
Console::WriteLine(value.ToString("0,0", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0}", value));	
// Displays 1,234,567,890      

CultureInfo^ elGR = CultureInfo::CreateSpecificCulture("el-GR");
Console::WriteLine(value.ToString("0,0", elGR));	
Console::WriteLine(String::Format(elGR, "{0:0,0}", value));	
// Displays 1.234.567.890

value = 1234567890.123456;
Console::WriteLine(value.ToString("0,0.0", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0.0}", value));	
// Displays 1,234,567,890.1  

value = 1234.567890;
Console::WriteLine(value.ToString("0,0.00", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0.00}", value));	
// Displays 1,234.57 
 double value;
 
 value = 123;
 Console.WriteLine(value.ToString("00000"));
 Console.WriteLine(String.Format("{0:00000}", value));
 // Displays 00123
 
 value = 1.2;
 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                   "{0:0.00}", value));
 // Displays 1.20

 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:00.00}", value));
 // Displays 01.20

 CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
 Console.WriteLine(value.ToString("00.00", daDK)); 
 Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
 // Displays 01,20
 
 value = .56;
 Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0.0}", value));
 // Displays 0.6

 value = 1234567890;
 Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0}", value));	
 // Displays 1,234,567,890      
 
 CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
 Console.WriteLine(value.ToString("0,0", elGR));	
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));	
 // Displays 1.234.567.890
 
 value = 1234567890.123456;
 Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.0}", value));	
 // Displays 1,234,567,890.1  
 
 value = 1234.567890;
 Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.00}", value));	
 // Displays 1,234.57 
Dim value As Double

value = 123
Console.WriteLine(value.ToString("00000"))
Console.WriteLine(String.Format("{0:00000}", value))
' Displays 00123

value = 1.2
Console.Writeline(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.Writeline(String.Format(CultureInfo.InvariantCulture, 
                  "{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:00.00}", value))
' Displays 01.20
Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK")
Console.WriteLine(value.ToString("00.00", daDK))
Console.WriteLine(String.Format(daDK, "{0:00.00}", value))
' Displays 01,20

value = .56
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.0}", value))
' Displays 0.6

value = 1234567890
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0}", value))	
' Displays 1,234,567,890      
Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR")
Console.WriteLine(value.ToString("0,0", elGR))
Console.WriteLine(String.Format(elGR, "{0:0,0}", value))	
' Displays 1.234.567.890

value = 1234567890.123456
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0.0}", value))	
' Displays 1,234,567,890.1  

value = 1234.567890
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0.00}", value))	
' Displays 1,234.57 

К таблицеBack to table

Настраиваемый описатель "#"The "#" custom specifier

Описатель настраиваемого формата "#" служит символом-заполнителем для цифр.The "#" custom format specifier serves as a digit-placeholder symbol. Если в форматируемом значении на позиции, где в строке формата присутствует символ "#", есть цифра, то эта цифра копируется в результирующую строку.If the value that is being formatted has a digit in the position where the "#" symbol appears in the format string, that digit is copied to the result string. В противном случае в выходной строке на этой позиции ничего не записывается.Otherwise, nothing is stored in that position in the result string.

Обратите внимание, что при использовании этого описателя незначащие нули не отображаются, даже если ноль является единственной цифрой в строке.Note that this specifier never displays a zero that is not a significant digit, even if zero is the only digit in the string. Ноль отображается только в том случае, если он является значащей цифрой отображаемого числа.It will display zero only if it is a significant digit in the number that is being displayed.

Строка формата "##" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичному разделителю, если назначено использование округления от нуля.The "##" format string causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. Например, в результате форматирования числа 34,5 с помощью строки "##" будет получена строка со значением "35".For example, formatting 34.5 with "##" would result in the value 35.

В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих заполнители для цифр.The following example displays several values that are formatted by using custom format strings that include digit placeholders.

 double value;
 
 value = 1.2;
 Console::WriteLine(value.ToString("#.##", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:#.##}", value));
 // Displays 1.2
 
 value = 123;
 Console::WriteLine(value.ToString("#####"));
 Console::WriteLine(String::Format("{0:#####}", value));
 // Displays 123

 value = 123456;
 Console::WriteLine(value.ToString("[##-##-##]"));      
 Console::WriteLine(String::Format("{0:[##-##-##]}", value));      
// Displays [12-34-56]

 value = 1234567890;
 Console::WriteLine(value.ToString("#"));
 Console::WriteLine(String::Format("{0:#}", value));
 // Displays 1234567890
 
 Console::WriteLine(value.ToString("(###) ###-####"));
 Console::WriteLine(String::Format("{0:(###) ###-####}", value));
 // Displays (123) 456-7890
  double value;
  
  value = 1.2;
  Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#.##}", value));
  // Displays 1.2
  
  value = 123;
  Console.WriteLine(value.ToString("#####"));
  Console.WriteLine(String.Format("{0:#####}", value));
  // Displays 123

  value = 123456;
  Console.WriteLine(value.ToString("[##-##-##]"));      
  Console.WriteLine(String.Format("{0:[##-##-##]}", value));      
// Displays [12-34-56]

  value = 1234567890;
  Console.WriteLine(value.ToString("#"));
  Console.WriteLine(String.Format("{0:#}", value));
  // Displays 1234567890
  
  Console.WriteLine(value.ToString("(###) ###-####"));
  Console.WriteLine(String.Format("{0:(###) ###-####}", value));
  // Displays (123) 456-7890
  Dim value As Double
  
  value = 1.2
  Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#.##}", value))
  ' Displays 1.2
  
  value = 123
  Console.WriteLine(value.ToString("#####"))
  Console.WriteLine(String.Format("{0:#####}", value))
  ' Displays 123

  value = 123456
  Console.WriteLine(value.ToString("[##-##-##]"))      
  Console.WriteLine(String.Format("{0:[##-##-##]}", value))      
' Displays [12-34-56]

  value = 1234567890
  Console.WriteLine(value.ToString("#"))
  Console.WriteLine(String.Format("{0:#}", value))
  ' Displays 1234567890

  Console.WriteLine(value.ToString("(###) ###-####"))
  Console.WriteLine(String.Format("{0:(###) ###-####}", value))
  ' Displays (123) 456-7890

Чтобы получить итоговую строку, в которой отсутствуют цифры или начальные нули заменены пробелами, используйте функциональность составного форматирования и укажите ширину поля, как показано в следующем примере.To return a result string in which absent digits or leading zeroes are replaced by spaces, use the composite formatting feature and specify a field width, as the following example illustrates.

using namespace System;

void main()
{
    Double value = .324;
    Console::WriteLine("The value is: '{0,5:#.###}'", value);
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'
using System;

public class Example
{
   public static void Main()
   {
      Double value = .324;
      Console.WriteLine("The value is: '{0,5:#.###}'", value);
   }
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'
Module Example
   Public Sub Main()
      Dim value As Double = .324
      Console.WriteLine("The value is: '{0,5:#.###}'", value)
   End Sub
End Module
' The example displays the following output if the current culture
' is en-US:
'      The value is: ' .324'

К таблицеBack to table

Настраиваемый описатель "."The "." custom specifier

Описатель настраиваемого формата "." вставляет в результирующую строку локализованный разделитель целой и дробной частей числа.The "." custom format specifier inserts a localized decimal separator into the result string. Первая точка в строке формата определяет расположение разделителя целой и дробной частей форматированного значения, а все прочие точки игнорируются.The first period in the format string determines the location of the decimal separator in the formatted value; any additional periods are ignored.

Символ, используемый в качестве разделителя целой и дробной части в результирующей строке, не всегда будет точкой; его значение определяется свойством NumberDecimalSeparator объекта NumberFormatInfo , управляющего форматированием.The character that is used as the decimal separator in the result string is not always a period; it is determined by the NumberDecimalSeparator property of the NumberFormatInfo object that controls formatting.

В следующем примере спецификатор формата "." используется для определения местоположения десятичного разделителя в нескольких выходных строках.The following example uses the "." format specifier to define the location of the decimal point in several result strings.

 double value;
 
 value = 1.2;
 Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:0.00}", value));
 // Displays 1.20

 Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:00.00}", value));
 // Displays 01.20

 Console::WriteLine(value.ToString("00.00", 
                   CultureInfo::CreateSpecificCulture("da-DK")));
 Console::WriteLine(String::Format(CultureInfo::CreateSpecificCulture("da-DK"),
                   "{0:00.00}", value));
 // Displays 01,20

 value = .086;
 Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture)); 
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:#0.##%}", value)); 
 // Displays 8.6%
  
 value = 86000;
 Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                   "{0:0.###E+0}", value));
// Displays 8.6E+4
  double value;
  
  value = 1.2;
  Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:0.00}", value));
  // Displays 1.20

  Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:00.00}", value));
  // Displays 01.20

  Console.WriteLine(value.ToString("00.00", 
                    CultureInfo.CreateSpecificCulture("da-DK")));
  Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                    "{0:00.00}", value));
  // Displays 01,20

  value = .086;
  Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)); 
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#0.##%}", value)); 
  // Displays 8.6%
   
  value = 86000;
  Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                    "{0:0.###E+0}", value));
// Displays 8.6E+4
  Dim value As Double
  
  value = 1.2
  Console.Writeline(value.ToString("0.00", CultureInfo.InvariantCulture))
  Console.Writeline(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:0.00}", value))
  ' Displays 1.20
  
  Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:00.00}", value))
  ' Displays 01.20

  Console.WriteLine(value.ToString("00.00", _
                    CultureInfo.CreateSpecificCulture("da-DK")))
  Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                    "{0:00.00}", value))
  ' Displays 01,20

  value = .086
  Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)) 
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#0.##%}", value)) 
  ' Displays 8.6%
   
  value = 86000
  Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                    "{0:0.###E+0}", value))
' Displays 8.6E+4

К таблицеBack to table

Настраиваемый описатель ","The "," custom specifier

Символ "," служит в качестве описателя разделителя групп и описателя масштабирования чисел.The "," character serves as both a group separator and a number scaling specifier.

  • Разделитель групп: если между двумя заполнителями для цифр ("0" или "#"), задающими форматирование целой части числа, стоит одна или несколько запятых, то между всеми группами целой части числа вставляется символ-разделитель групп.Group separator: If one or more commas are specified between two digit placeholders (0 or #) that format the integral digits of a number, a group separator character is inserted between each number group in the integral part of the output.

    Свойства NumberGroupSeparator и NumberGroupSizes текущего объекта NumberFormatInfo определяют знак, используемый в качестве разделителя групп числа и размера каждой группы числа.The NumberGroupSeparator and NumberGroupSizes properties of the current NumberFormatInfo object determine the character used as the number group separator and the size of each number group. Например, если строка "#,#" и неизменяемый язык и региональные параметры используются для форматирования числа 1000, то результатом является "1,000".For example, if the string "#,#" and the invariant culture are used to format the number 1000, the output is "1,000".

  • Описатель масштабирования чисел: если сразу слева от явно или неявно заданного разделителя целой и дробной части стоит одна или несколько запятых, форматируемое число делится на 1000 для каждой указанной запятой.Number scaling specifier: If one or more commas are specified immediately to the left of the explicit or implicit decimal point, the number to be formatted is divided by 1000 for each comma. Например, если строка "0,," используется для форматирования числа 100 миллионов, то результатом является "100".For example, if the string "0,," is used to format the number 100 million, the output is "100".

Разделитель групп и описатель масштабирования чисел можно использовать в строке формата одновременно.You can use group separator and number scaling specifiers in the same format string. Например, если строка "#, 0,," и неизменяемый язык и региональные параметры используются для форматирования числа один миллиард, то результатом является "1,000".For example, if the string "#,0,," and the invariant culture are used to format the number one billion, the output is "1,000".

В следующем примере демонстрируется использование запятой в качестве разделителя групп.The following example illustrates the use of the comma as a group separator.

double value = 1234567890;
Console::WriteLine(value.ToString("#,#", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#,#}", value));
// Displays 1,234,567,890      

Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#,##0,,}", value));
// Displays 1,235      	
double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,#}", value));
// Displays 1,234,567,890      

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,##0,,}", value));
// Displays 1,235      	
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,#}", value))
' Displays 1,234,567,890      

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,##0,,}", value))
' Displays 1,235      	

Следующий пример иллюстрирует использование запятой как спецификатора масштабирования числа.The following example illustrates the use of the comma as a specifier for number scaling.

  double value = 1234567890;
  Console::WriteLine(value.ToString("#,,", CultureInfo::InvariantCulture));	
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,,}", value));	
  // Displays 1235   
  
  Console::WriteLine(value.ToString("#,,,", CultureInfo::InvariantCulture));
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,,,}", value));
// Displays 1  
  
  Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));       
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,##0,,}", value));       
// Displays 1,235
   double value = 1234567890;
   Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));	
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,}", value));	
   // Displays 1235   
   
   Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,,}", value));
// Displays 1  
   
   Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));       
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,##0,,}", value));       
// Displays 1,235
  Dim value As Double = 1234567890
  Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture))	
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0:#,,}", value))	
  ' Displays 1235   

  Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#,,,}", value))
' Displays 1  

  Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))       
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#,##0,,}", value))       
' Displays 1,235

К таблицеBack to table

Настраиваемый описатель "%"The "%" custom specifier

При использовании символа процента ("%") в строке формата число перед форматированием будет умножено на 100.A percent sign (%) in a format string causes a number to be multiplied by 100 before it is formatted. В то место, где в строке формата стоит символ "%", в число будет вставлен локализованный символ процента.The localized percent symbol is inserted in the number at the location where the % appears in the format string. Используемый при этом символ процента определяется свойством PercentSymbol текущего объекта NumberFormatInfo .The percent character used is defined by the PercentSymbol property of the current NumberFormatInfo object.

В следующем примере определяется несколько строк настраиваемого формата, включающих настраиваемый описатель "%".The following example defines several custom format strings that include the "%" custom specifier.

double value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#0.##%}", value));
// Displays 8.6%      
double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#0.##%}", value));
// Displays 8.6%      
Dim value As Double = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#0.##%}", value))
' Displays 8.6%      

К таблицеBack to table

Настраиваемый описатель "‰"The "‰" custom specifier

При использовании в строке формата символа промилле ("‰" или "\u2030") перед форматированием число будет умножено на 1000.A per mille character (‰ or \u2030) in a format string causes a number to be multiplied by 1000 before it is formatted. В позицию возвращаемой строки, соответствующую положению символа "‰" в строке формата, будет вставлен необходимый символ промилле.The appropriate per mille symbol is inserted in the returned string at the location where the ‰ symbol appears in the format string. Используемый знак промилле определяется значением свойства NumberFormatInfo.PerMilleSymbol объекта, содержащего сведения о форматировании для заданного языка и региональных параметров.The per mille character used is defined by the NumberFormatInfo.PerMilleSymbol property of the object that provides culture-specific formatting information.

В следующем примере определяется строка настраиваемого формата, включающая настраиваемый описатель "‰".The following example defines a custom format string that includes the "‰" custom specifier.

double value = .00354;
String^ perMilleFmt = "#0.## " + '\u2030';
Console::WriteLine(value.ToString(perMilleFmt, CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰      
double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰      
Dim value As Double = .00354
Dim perMilleFmt As String = "#0.## " & ChrW(&h2030)
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value))
' Displays 3.54 ‰      

К таблицеBack to table

Настраиваемые описатели "E" и "e"The "E" and "e" custom specifiers

Если в строке формата присутствует подстрока "E", "E+", "E-", "e", "e+" или "e-", за которой сразу следует по меньшей мере один ноль, то число форматируется с использованием экспоненциальной нотации. Между числом и экспонентой при этом вставляется символ "E" или "e".If any of the strings "E", "E+", "E-", "e", "e+", or "e-" are present in the format string and are followed immediately by at least one zero, the number is formatted by using scientific notation with an "E" or "e" inserted between the number and the exponent. Минимальное число цифр экспоненты в результирующей строке определяется количеством нулей, стоящих после индикатора экспоненциальной нотации.The number of zeros following the scientific notation indicator determines the minimum number of digits to output for the exponent. Форматы "E+" и "e+" указывают на то, что перед экспонентой всегда должен стоять положительный или отрицательный знак.The "E+" and "e+" formats indicate that a plus sign or minus sign should always precede the exponent. Форматы "E", "e", "E-" и "e-" указывают на то, что символ знака должен ставиться только перед экспонентой с отрицательным значением.The "E", "E-", "e", or "e-" formats indicate that a sign character should precede only negative exponents.

В следующем примере несколько числовых значений форматируются с помощью спецификаторов экспоненциального представления.The following example formats several numeric values using the specifiers for scientific notation.

double value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console::WriteLine(value.ToString("0.###E+000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console::WriteLine(value.ToString("0.###E-000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E-000}", value));
// Displays 8.6E004
double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E-000}", value));
// Displays 8.6E004
Dim value As Double = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+0}", value))
' Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+000}", value))
' Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E-000}", value))
' Displays 8.6E004

К таблицеBack to table

Escape-символ "\"The "\" escape character

Символы "#", "0", ".", ",", "%" и "‰" в строке формата воспринимаются как описатели формата, а не как символы-литералы.The "#", "0", ".", ",", "%", and "‰" symbols in a format string are interpreted as format specifiers rather than as literal characters. В зависимости от положения в строке настраиваемого формата символ "E" верхнего и нижнего регистра, также как и символы "+" и "-", могут восприниматься как описатели формата.Depending on their position in a custom format string, the uppercase and lowercase "E" as well as the + and - symbols may also be interpreted as format specifiers.

Чтобы предотвратить интерпретацию символа в качестве описателя формата, перед ним можно поставить так называемый escape-символ — обратную косую черту.To prevent a character from being interpreted as a format specifier, you can precede it with a backslash, which is the escape character. Наличие escape-символа означает, что следующий за ним символ является литералом, который следует перенести в результирующую строку без изменений.The escape character signifies that the following character is a character literal that should be included in the result string unchanged.

Чтобы включить в результирующую строку обратную косую черту, перед ней нужно поставить дополнительную обратную косую черту (\\).To include a backslash in a result string, you must escape it with another backslash (\\).

Примечание

Кроме того, в некоторых компиляторах, например компиляторах C++ и C#, одиночная обратная косая черта также может восприниматься как escape-символ.Some compilers, such as the C++ and C# compilers, may also interpret a single backslash character as an escape character. Чтобы гарантировать, что строка будет правильно воспринята при форматировании, можно поставить символ буквального строкового литерала (символ "@") перед строкой в C# или добавить дополнительный символ обратной косой черты перед каждой обратной косой чертой в C# и C++.</span><span class="sxs-lookup">To ensure that a string is interpreted correctly when formatting, you can use the verbatim string literal character (the @ character) before the string in C#, or add another backslash character before each backslash in C# and C++. В следующем примере кода на языке C# демонстрируются оба подхода.The following C# example illustrates both approaches.

В следующем примере интерпретация символов #, 0 и \ в качестве escape-символов или описателей формата при форматировании предотвращается с помощью escape-символа.The following example uses the escape character to prevent the formatting operation from interpreting the "#", "0", and "\" characters as either escape characters or format specifiers. В примерах на языке C# используется дополнительная обратная косая черта, позволяющая гарантировать, что обратная косая черта будет воспринята как символ-литерал.The C# examples uses an additional backslash to ensure that a backslash is interpreted as a literal character.

int value = 123;
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                  value));
// Displays ### 123 dollars and 00 cents ###

Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console::WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console::WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\
int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\
Dim value As Integer = 123
Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#"))
Console.WriteLine(String.Format("{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}", 
                                value))
' Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"))
Console.WriteLine(String.Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}", 
                                value))
' Displays \\\ 123 dollars and 00 cents \\\

К таблицеBack to table

Разделитель секций ";"The ";" section separator

Точка с запятой (";") — это описатель условного формата, применяющий разное форматирование к числу в зависимости от того, является оно положительным числом, отрицательным числом или нулем.The semicolon (;) is a conditional format specifier that applies different formatting to a number depending on whether its value is positive, negative, or zero. Для этого следует создать строку формата, состоящую из трех секций, разделенных точкой с запятой.To produce this behavior, a custom format string can contain up to three sections separated by semicolons. Эти секции описаны в следующей таблице.These sections are described in the following table.

Число секцийNumber of sections Описание:Description
Одна секцияOne section Строка форматирования применяется ко всем значениям.The format string applies to all values.
Две секцииTwo sections Первая секция применяется для положительных значений и нулей, вторая секция применяется для отрицательных значений.The first section applies to positive values and zeros, and the second section applies to negative values.

Если форматируемое число является отрицательным, но становится нулем в результате округления в соответствии с форматом, заданным во второй секции, то результирующий ноль форматируется в соответствии с первой секцией.If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, the resulting zero is formatted according to the first section.
Три секцииThree sections Первая секция применяется для положительных значений, вторая секция применяется для отрицательных значений, а третья — для нулей.The first section applies to positive values, the second section applies to negative values, and the third section applies to zeros.

Вторая секция может быть пустой (между двумя точками с запятой пусто), в этом случае первая секция будет использоваться для форматирования нулевых значений.The second section can be left empty (by having nothing between the semicolons), in which case the first section applies to all nonzero values.

Если форматируемое число является ненулевым, но становится нулем в результате округления в соответствии с форматом в первой или второй секции, то результирующий ноль форматируется в соответствии с третьей секцией.If the number to be formatted is nonzero, but becomes zero after rounding according to the format in the first or second section, the resulting zero is formatted according to the third section.

При форматировании конечного значения разделители секций игнорируют любое существовавшее ранее форматирование, связанное с числом.Section separators ignore any preexisting formatting associated with a number when the final value is formatted. Например, при использовании разделителей секций отрицательные значения всегда отображаются без знака "минус".For example, negative values are always displayed without a minus sign when section separators are used. Чтобы конечное отформатированное значение содержало знак "минус", его следует явным образом включить в настраиваемый спецификатор формата.If you want the final formatted value to have a minus sign, you should explicitly include the minus sign as part of the custom format specifier.

В следующем примере описатель формата ";" используется для форматирования положительных чисел, отрицательных чисел и нулей различными способами.The following example uses the ";" format specifier to format positive, negative, and zero numbers differently.

double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

String^ fmt2 = "##;(##)";
String^ fmt3 = "##;(##);**Zero**";

Console::WriteLine(posValue.ToString(fmt2));  
Console::WriteLine(String::Format("{0:" + fmt2 + "}", posValue));    
// Displays 1234

Console::WriteLine(negValue.ToString(fmt2));  
Console::WriteLine(String::Format("{0:" + fmt2 + "}", negValue));    
// Displays (1234)

Console::WriteLine(zeroValue.ToString(fmt3)); 
Console::WriteLine(String::Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";

Console.WriteLine(posValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));    
// Displays 1234

Console.WriteLine(negValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));    
// Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3)); 
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
Dim posValue As Double = 1234
Dim negValue As Double = -1234
Dim zeroValue As Double = 0

Dim fmt2 As String = "##;(##)"
Dim fmt3 As String = "##;(##);**Zero**"

Console.WriteLine(posValue.ToString(fmt2))   
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue))    
' Displays 1234

Console.WriteLine(negValue.ToString(fmt2))   
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue))    
' Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3))  
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue))
' Displays **Zero**

К таблицеBack to table

Символьные литералыCharacter literals

Описатели формата, которые появляются в строке настраиваемых числовых форматов, всегда интерпретируются как символы формата и никогда не обрабатываются как литеральные символы.Format specifiers that appear in a custom numeric format string are always interpreted as formatting characters and never as literal characters. К ним относятся следующие символы:This includes the following characters:

  • 00
  • #
  • %
  • ''
  • \
  • ..
  • ,,
  • E или e, в зависимости от положения в строке формата.E or e, depending on its position in the format string.

Все остальные символы всегда интерпретируется как символьные литералы. В операции форматирования они включаются в результирующую строку без изменений.All other characters are always interpreted as character literals and, in a formatting operation, are included in the result string unchanged. В операции анализа они должны точно соответствовать символам во входной строке. При сравнении учитывается регистр.In a parsing operation, they must match the characters in the input string exactly; the comparison is case-sensitive.

В следующем примере демонстрируется распространенный пример применения литеральных символов единиц измерения (в данном случае тысяч):The following example illustrates one common use of literal character units (in this case, thousands):

double n = 123.8;
Console.WriteLine($"{n:#,##0.0K}");
// The example displays the following output:
//      123.8K   
Dim n As Double = 123.8
Console.WriteLine($"{n:#,##0.0K}")
' The example displays the following output:
'       123.8K

Указать необходимость интерпретации символов как литеральных, а не как символов формата, для их последующего включения в результирующую строку или успешного анализа во входной строке можно двумя способами:There are two ways to indicate that characters are to be interpreted as literal characters and not as formatting characters, so that they can be included in a result string or successfully parsed in an input string:

  • Путем экранирования символа формата.By escaping a formatting character. Дополнительные сведения см. в разделе Escape-символ "\".For more information, see The "\" escape character.

  • Путем заключения всей литеральной строки в апострофы.By enclosing the entire literal string in quotation apostrophes.

В следующем примере применяются оба подхода, что позволяет включить зарезервированные символы в настраиваемую строку числового формата.The following example uses both approaches to include reserved characters in a custom numeric format string.

 [!code-csharp-interactive[including reserved characters](~/samples/snippets/csharp/VS_Snippets_CLR/formatting.numeric.custom/cs/literal1.cs#1)]
 [!code-vb[including reserved characters](~/samples/snippets/visualbasic/VS_Snippets_CLR/formatting.numeric.custom/vb/literal1.vb#1)]  

ПримечанияNotes

Бесконечности действительных чисел с плавающей запятой и NaNFloating-Point infinities and NaN

Если вне зависимости от строки формата значение типа с плавающей запятой Single или Double является положительной бесконечностью, отрицательной бесконечностью или не является числом (NaN), отформатированная строка будет содержать значение соответствующего свойства ( PositiveInfinitySymbol, NegativeInfinitySymbolили NaNSymbol ), применимого в настоящий момент объекта 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 specified by the currently applicable NumberFormatInfo object.

Параметры панели управленияControl Panel settings

Параметры элемента панели управления Язык и региональные стандарты влияют на выходную строку, получаемую в результате операции форматирования.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Эти параметры используются для инициализации объекта NumberFormatInfo , связанного с текущей культурой потока, а текущая культура потока предоставляет значения, которые используются для управления форматированием.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, and the current thread culture provides values used to govern formatting. Результирующие строки будут различаться на компьютерах с разными параметрами.Computers that use different settings generate different result strings.

Кроме того, если конструктор CultureInfo.CultureInfo(String) используется для создания экземпляра объекта CultureInfo, который представляет язык и региональные параметры, аналогичные текущему языку и региональным параметрам системы, все настройки, заданные в разделе Язык и региональные стандарты панели управления, будут применяться к новому объекту CultureInfo.In addition, if you use the CultureInfo.CultureInfo(String) constructor 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. Можно воспользоваться конструктором CultureInfo.CultureInfo(String, Boolean) для создания объекта CultureInfo, который не отражает настройки системы.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Строки формата с фиксированной запятой и округлениемRounding and fixed-point format strings

Строки формата с фиксированной запятой (строки формата, не содержащие символов экспоненциальной нотации) округляют значение с точностью, определяемой количеством символов-заполнителей, стоящих справа от разделителя целой и дробной частей.For fixed-point format strings (that is, format strings that do not contain scientific notation format characters), numbers are rounded to as many decimal places as there are digit placeholders to the right of the decimal point. Если в строке формата нет десятичной точки, то число округляется до ближайшего целого значения.If the format string does not contain a decimal point, the number is rounded to the nearest integer. Если слева от десятичной точки больше цифр, чем знаков-заместителей цифр, то лишние знаки копируются в выходную строку перед первым знаком-заместителем цифры.If the number has more digits than there are digit placeholders to the left of the decimal point, the extra digits are copied to the result string immediately before the first digit placeholder.

К таблицеBack to table

ПримерExample

В следующем примере показаны две строки настраиваемого числового формата.The following example demonstrates two custom numeric format strings. В обоих случаях заполнитель для цифр (#) отображает числовые данные, а все остальные символы копируются в результирующую строку.In both cases, the digit placeholder (#) displays the numeric data, and all other characters are copied to the result string.

double number1 = 1234567890;
String^ value1 = number1.ToString("(###) ###-####");
Console::WriteLine(value1);

int number2 = 42;
String^ value2 = number2.ToString("My Number = #");
Console::WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42
double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);

int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42
Dim number1 As Double = 1234567890
Dim value1 As String = number1.ToString("(###) ###-####")
Console.WriteLine(value1)

Dim number2 As Integer = 42
Dim value2 As String = number2.ToString("My Number = #")
Console.WriteLine(value2)
' The example displays the following output:
'       (123) 456-7890
'       My Number = 42

К таблицеBack to table

См. такжеSee also

System.Globalization.NumberFormatInfo
Типы форматированияFormatting Types
Standard Numeric Format StringsStandard Numeric Format Strings
Практическое руководство. Добавление к числу начальных нулейHow to: Pad a Number with Leading Zeros
Пример. Служебная программа форматирования для .NET Framework 4Sample: .NET Framework 4 Formatting Utility