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

Чтобы определить способ форматирования числовых данных, можно создать строку настраиваемого числового формата, состоящую из одного или нескольких описателей настраиваемого формата. Строка настраиваемого числового формата — это любая строка формата, не являющаяся строкой стандартного числового формата.

Строки настраиваемых числовых форматов поддерживаются некоторыми перегрузками метода ToString всех числовых типов. Например, можно задать строку числового формата для методов ToString(String) и ToString(String, IFormatProvider) типа Int32 . Строки настраиваемых числовых форматов также поддерживаются функцией составного форматирования .NET Framework, используемой некоторыми методами Write и WriteLine классов Console и StreamWriter, а также методами String.Format и StringBuilder.AppendFormat. Функция интерполяции строк также поддерживает строки настраиваемого числового формата.

Совет

Вы можете загрузить служебную программу форматирования — приложение Windows Forms для .NET Core, позволяющее применять строки формата к значениям даты и времени и числовым значениям и отображающее результирующую строку. Исходный код доступен для C# и Visual Basic.

В следующей таблице приведены описатели стандартного числового формата и примеры выходных данных, формируемых каждым описателем формата. Дополнительные сведения об использовании строк настраиваемого числового формата см. в разделе Примечания ; обширную демонстрацию их использования см. в разделе Пример .

Спецификатор формата	Имя	Описание	Примеры
"0"	Знак-заместитель нуля	Заменяет ноль соответствующей цифрой, если такая имеется. В противном случае в результирующей строке будет стоять ноль. Дополнительные сведения: Настраиваемый описатель "0".	1234.5678 ("00000") -> 01235 0.45678 ("0.00", en-US) -> 0,46 0.45678 ("0,00", fr-FR) -> 0,46
"#"	Заместитель цифры	Заменяет знак "#" соответствующей цифрой, если такая имеется. В противном случае в результирующей строке не будет цифры. Обратите внимание, что в итоговой строке не будет отображаться цифра, если соответствующей цифрой в строке ввода является незначащий 0. Например, 0003 ("###") —> 3. Дополнительные сведения: Настраиваемый описатель "#".	1234.5678 ("####") -> 1235 0.45678 ("#.#", en-US) -> 46 0.45678 ("#.#", fr-FR) -> 46
"."	Разделитель	Определяет расположение разделителя целой и дробной частей в результирующей строке. Дополнительные сведения: Настраиваемый разделитель ".".	0.45678 ("0.00", en-US) -> 0,46 0.45678 ("0,00", fr-FR) -> 0,46
","	Разделитель групп и масштабирование чисел	Служит в качестве описателя разделителя групп и описателя масштабирования чисел. В качестве разделителя групп вставляет локализованный символ-разделитель групп между всеми группами. В качестве описателя масштабирования чисел делит число на 1000 для всех указанных запятых. Дополнительные сведения: Настраиваемый описатель ",".	Описатель разделителя групп: 2147483647 ("#,#", en-US) -> 2,147 483 647 2147483647 ("#,#", es-ES) -> 2.147.483.647 Описатель масштабирования: 2147483647 ("#,#,", en-US) -> 2,147 2147483647 ("#,#,", es-ES) -> 2.147
"%"	Заместитель процентов	Умножает число на 100 и вставляет локализованный символ процента в результирующую строку. Дополнительные сведения: Настраиваемый описатель "%".	0.3697 ("%#0.00", en-US) -> %36.97 0.3697 ("%#0.00", el-GR) -> %36,97 0.3697 ("#.0 %", en-US) -> 37,0 % 0.3697 ("#.0 %", el-GR) -> 37,0 %
"‰"	Местозаполнитель промилле	Умножает число на 1000 и вставляет локализованный символ промилле в результирующую строку. Дополнительные сведения: Настраиваемый описатель "‰".	0.03697 ("#0.00", en-US) -> 36,97!" 0.03697 ("#0,00", ru-RU) -> 36,97"
"E0" "E+0" "E-0" "E0" "E+0" "E-0"	Экспоненциальная нотация	Если за этим описателем следует по меньшей мере один ноль (0), результат форматируется с использованием экспоненциальной нотации. Регистр ("E" или "e") определяет регистр символа экспоненты в результирующей строке. Минимальное число цифр экспоненты определяется количеством нулей, стоящих за символом "E" или "e". Знак "+" указывает на то, что перед экспонентой всегда должен ставиться символ знака. Знак "-" указывает на то, что символ знака должен ставиться только в случае, если экспонента имеет отрицательное значение. Дополнительные сведения: Настраиваемые описатели "E" и "e".	987654 ("#0.0e0") -> 98.8e4 1503.92311 ("0.0##e+00") -> 1.504e+03 1.8901385E-16 ("0.0e+00") -> 1.9e-16
"\"	Escape-символ	Указывает на то, что следующий за ним символ должен рассматриваться как литерал, а не как описатель настраиваемого формата. Дополнительные сведения: escape-символ "\".	987654 ("\##00\#") -> #987654#
'string' string	Разделитель строк-литералов	Указывает на то, что заключенные в разделители символы должны быть скопированы в результирующую строку без изменений. Дополнительные сведения см. в подразделе Символьные литералы.	68 ("# "градусы") -> 68 градусов 68 ("#' degrees'") -> 68 градусов
;	Разделитель секций	Определяет секции с раздельными строками формата для положительных чисел, отрицательных чисел и нуля. Дополнительные сведения: Разделитель секций ";".	12.345 ("#0.0#;( #0.0#;-\0-") -> 12.35 0 ("#0.0#;( #0.0#;-\0-") -> -0- -12.345 ("#0.0#;( #0.0#;-\0-") -> (12.35) 12.345 ("#0.0#;( #0.0#)") —> 12.35 0 ("#0.0#;( #0.0#)") —> 0.0 -12.345 ("#0.0#;( #0.0#)") -> (12.35)
Другой	Все остальные символы	Символ копируется в результирующую строку без изменений. Дополнительные сведения см. в подразделе Символьные литералы.	68 ("# °") -> 68 °

В приведенных ниже разделах содержится подробная информация о всех описателях настраиваемого числового формата.

Примечание.

Некоторые примеры C# в этой статье выполняются во встроенном средстве выполнения кода и на тестовой площадке Try.NET. Нажмите на кнопку Выполнить, чтобы выполнить пример в интерактивном окне. После выполнения кода вы можете изменить его и выполнить измененный код, снова нажав на кнопку Выполнить. Либо в интерактивном окне выполняется измененный код, либо, если компиляция завершается с ошибкой, в интерактивном окне отображаются все сообщения об ошибках компилятора C#.

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

Описатель настраиваемого формата "0" служит нулевым символом-заполнителем. Если форматируемое значение содержит цифру в позиции, где в строке формата стоит ноль, то эта цифра копируется в результирующую строку; в противном случае в результирующей строке будет стоять ноль. Позиция крайнего левого нуля перед разделителем целой и дробной частей и позиция крайнего правого нуля после разделителя целой и дробной частей определяют диапазон цифр, которые всегда включаются в результирующую строку.

Спецификатор "00" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичной точке-разделителю, если назначено использование округления от нуля. Например, в результате форматирования числа 34,5 с помощью строки "00" будет получена строка со значением"35".

В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих нулевые заполнители.

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

К таблице

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

Описатель настраиваемого формата "#" служит символом-заполнителем для цифр. Если в форматируемом значении на позиции, где в строке формата присутствует символ "#", есть цифра, то эта цифра копируется в результирующую строку. В противном случае в выходной строке на этой позиции ничего не записывается.

Обратите внимание, что при использовании этого описателя незначащие нули не отображаются, даже если ноль является единственной цифрой в строке. Ноль отображается только в том случае, если он является значащей цифрой отображаемого числа.

Строка формата "##" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичному разделителю, если назначено использование округления от нуля. Например, в результате форматирования числа 34,5 с помощью строки "##" будет получена строка со значением "35".

В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих заполнители для цифр.

 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

Чтобы получить итоговую строку, в которой отсутствуют цифры или начальные нули заменены пробелами, используйте функциональность составного форматирования и укажите ширину поля, как показано в следующем примере.

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 SpaceOrDigit
{
   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 SpaceExample
    Public Sub Main()
        Dim value As Double = 0.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'

К таблице

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

Описатель настраиваемого формата "." вставляет в результирующую строку локализованный разделитель целой и дробной частей числа. Первая точка в строке формата определяет расположение разделителя целой и дробной частей форматированного значения, а все прочие точки игнорируются. Если описатель формата заканчивается "." только значимыми цифрами, отформатированными в результирующем строке.

Символ, используемый в качестве разделителя целой и дробной части в результирующей строке, не всегда будет точкой; его значение определяется свойством NumberDecimalSeparator объекта NumberFormatInfo , управляющего форматированием.

В следующем примере спецификатор формата "." используется для определения местоположения десятичного разделителя в нескольких выходных строках.

 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

К таблице

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

Символ "," служит в качестве описателя разделителя групп и описателя масштабирования чисел.

• Разделитель групп: если между двумя заполнителями для цифр ("0" или "#"), задающими форматирование целой части числа, стоит одна или несколько запятых, то между всеми группами целой части числа вставляется символ-разделитель групп.

  Свойства NumberGroupSeparator и NumberGroupSizes текущего объекта NumberFormatInfo определяют знак, используемый в качестве разделителя групп числа и размера каждой группы числа. Например, если строка "#,#" и неизменяемый язык и региональные параметры используются для форматирования числа 1000, то результатом является "1,000".

• Описатель масштабирования чисел: если сразу слева от явно или неявно заданного разделителя целой и дробной части стоит одна или несколько запятых, форматируемое число делится на 1000 для каждой указанной запятой. Например, если строка "0,," используется для форматирования числа 100 миллионов, то результатом является "100".

Разделитель групп и описатель масштабирования чисел можно использовать в строке формата одновременно. Например, если строка "#, 0,," и неизменяемый язык и региональные параметры используются для форматирования числа один миллиард, то результатом является "1,000".

В следующем примере демонстрируется использование запятой в качестве разделителя групп.

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

Следующий пример иллюстрирует использование запятой как спецификатора масштабирования числа.

  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

К таблице

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

При использовании символа процента ("%") в строке формата число перед форматированием будет умножено на 100. В то место, где в строке формата стоит символ "%", в число будет вставлен локализованный символ процента. Используемый при этом символ процента определяется свойством PercentSymbol текущего объекта NumberFormatInfo .

В следующем примере определяется несколько строк настраиваемого формата, включающих настраиваемый описатель "%".

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%

К таблице

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

При использовании в строке формата символа промилле ("‰" или "\u2030") перед форматированием число будет умножено на 1000. В позицию возвращаемой строки, соответствующую положению символа "‰" в строке формата, будет вставлен необходимый символ промилле. Используемый знак промилле определяется значением свойства NumberFormatInfo.PerMilleSymbol объекта, содержащего сведения о форматировании для заданного языка и региональных параметров.

В следующем примере определяется строка настраиваемого формата, включающая настраиваемый описатель "‰".

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 ‰

К таблице

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

Если в строке формата присутствует подстрока "E", "E+", "E-", "e", "e+" или "e-", за которой сразу следует по меньшей мере один ноль, то число форматируется с использованием экспоненциальной нотации. Между числом и экспонентой при этом вставляется символ "E" или "e". Минимальное число цифр экспоненты в результирующей строке определяется количеством нулей, стоящих после индикатора экспоненциальной нотации. Форматы "E+" и "e+" указывают на то, что перед экспонентой всегда должен стоять положительный или отрицательный знак. Форматы "E", "e", "E-" и "e-" указывают на то, что символ знака должен ставиться только перед экспонентой с отрицательным значением.

В следующем примере несколько числовых значений форматируются с помощью спецификаторов экспоненциального представления.

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

К таблице

Escape-символ "\"

Символы "#", "0", ".", ",", "%" и "‰" в строке формата воспринимаются как описатели формата, а не как символы-литералы. В зависимости от положения в строке настраиваемого формата символ "E" верхнего и нижнего регистра, также как и символы "+" и "-", могут восприниматься как описатели формата.

Чтобы предотвратить интерпретацию символа в качестве описателя формата, перед ним можно поставить так называемый escape-символ — обратную косую черту. Наличие escape-символа означает, что следующий за ним символ является литералом, который следует перенести в результирующую строку без изменений.

Чтобы включить в результирующую строку обратную косую черту, перед ней нужно поставить дополнительную обратную косую черту (\\).

Примечание.

Кроме того, в некоторых компиляторах, например компиляторах C++ и C#, одиночная обратная косая черта также может восприниматься как escape-символ. Чтобы гарантировать, что строка будет правильно воспринята при форматировании, можно поставить символ буквального строкового литерала (символ "\@") перед строкой в C# или добавить дополнительный символ обратной косой черты перед каждой обратной косой чертой в C# и C++. В следующем примере кода на языке C# демонстрируются оба подхода.

В следующем примере используется escape-символ для предотвращения интерпретации символов форматирования "#", "0" и "\" как escape-символов или описателей формата. В примерах на языке C# используется дополнительная обратная косая черта, позволяющая гарантировать, что обратная косая черта будет воспринята как символ-литерал.

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

К таблице

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

Точка с запятой (";") — это описатель условного формата, применяющий разное форматирование к числу в зависимости от того, является оно положительным числом, отрицательным числом или нулем. Для этого следует создать строку формата, состоящую из трех секций, разделенных точкой с запятой. Эти секции описаны в следующей таблице.

Число секций	Description
Один раздел	Строка форматирования применяется ко всем значениям.
Два раздела	Первая секция применяется для положительных значений и нулей, вторая секция применяется для отрицательных значений. Если форматируемое число является отрицательным, но становится нулем в результате округления в соответствии с форматом, заданным во второй секции, то результирующий ноль форматируется в соответствии с первой секцией.
Три раздела	Первая секция применяется для положительных значений, вторая секция применяется для отрицательных значений, а третья — для нулей. Вторая секция может быть пустой (между двумя точками с запятой пусто), в этом случае первая секция будет использоваться для форматирования нулевых значений. Если форматируемое число является ненулевым, но становится нулем в результате округления в соответствии с форматом в первой или второй секции, то результирующий ноль форматируется в соответствии с третьей секцией.

При форматировании конечного значения разделители секций игнорируют любое существовавшее ранее форматирование, связанное с числом. Например, при использовании разделителей секций отрицательные значения всегда отображаются без знака "минус". Чтобы конечное отформатированное значение содержало знак "минус", его следует явным образом включить в настраиваемый спецификатор формата.

В следующем примере описатель формата ";" используется для форматирования положительных чисел, отрицательных чисел и нулей различными способами.

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

К таблице

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

Описатели формата, которые появляются в строке настраиваемых числовых форматов, всегда интерпретируются как символы формата и никогда не обрабатываются как литеральные символы. К ним относятся следующие символы:

• 0
• #
• %
• ‰
• '
• \
• .
• ,
• E или e, в зависимости от положения в строке формата.

Все остальные символы всегда интерпретируется как символьные литералы. В операции форматирования они включаются в результирующую строку без изменений. В операции анализа они должны точно соответствовать символам во входной строке. При сравнении учитывается регистр.

В следующем примере демонстрируется распространенный пример применения литеральных символов единиц измерения (в данном случае тысяч):

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

Указать необходимость интерпретации символов как литеральных, а не как символов формата, для их последующего включения в результирующую строку или успешного анализа во входной строке можно двумя способами:

• Путем экранирования символа формата. Дополнительные сведения см. в разделе "\" escape-символ.

• Путем заключения всей литеральной строки в апострофы.

В следующем примере применяются оба подхода, что позволяет включить зарезервированные символы в настраиваемую строку числового формата.

double n = 9.3;
Console.WriteLine($@"{n:##.0\%}");
Console.WriteLine($@"{n:\'##\'}");
Console.WriteLine($@"{n:\\##\\}");
Console.WriteLine();
Console.WriteLine($"{n:##.0'%'}");
Console.WriteLine($@"{n:'\'##'\'}");
// The example displays the following output:
//      9.3%
//      '9'
//      \9\
//
//      9.3%
//      \9\

Dim n As Double = 9.3
Console.WriteLine($"{n:##.0\%}")
Console.WriteLine($"{n:\'##\'}")
Console.WriteLine($"{n:\\##\\}")
Console.WriteLine()
Console.WriteLine($"{n:##.0'%'}")
Console.WriteLine($"{n:'\'##'\'}")
' The example displays the following output:
'      9.3%
'      '9'
'      \9\
'
'      9.3%
'      \9\

Примечания.

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

Независимо от строки форматирования, если значение Halfтипа с DoubleSingleплавающей запятой является положительным бесконечностью, отрицательным бесконечностью или не числом (NaN), форматированная строка является значением соответствующего PositiveInfinitySymbolили NegativeInfinitySymbolNaNSymbol свойства, заданного текущим применимым NumberFormatInfo объектом.

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

Параметры элемента панели управления Язык и региональные стандарты влияют на выходную строку, получаемую в результате операции форматирования. Эти параметры используются для инициализации объекта, связанного NumberFormatInfo с текущим языком и региональными параметрами, а текущий язык и региональные параметры предоставляют значения, используемые для управления форматированием. Результирующие строки будут различаться на компьютерах с разными параметрами.

Кроме того, если конструктор CultureInfo(String) используется для создания нового экземпляра объекта CultureInfo , представляющего язык и региональные параметры, аналогичные текущему языку и региональным параметрам системы, то все настройки, заданные в разделе Язык и региональные стандарты панели управления, будут применяться к новому объекту CultureInfo . Можно воспользоваться конструктором CultureInfo(String, Boolean) для создания объекта CultureInfo , который не отражает настройки системы.

Строки формата с фиксированной запятой и округлением

Строки формата с фиксированной запятой (строки формата, не содержащие символов экспоненциальной нотации) округляют значение с точностью, определяемой количеством символов-заполнителей, стоящих справа от разделителя целой и дробной частей. Если в строке формата нет десятичной точки, то число округляется до ближайшего целого значения. Если слева от десятичной точки больше цифр, чем знаков-заместителей цифр, то лишние знаки копируются в выходную строку перед первым знаком-заместителем цифры.

К таблице

Пример

В следующем примере показаны две строки настраиваемого числового формата. В обоих случаях заполнитель для цифр (#) отображает числовые данные, а все остальные символы копируются в результирующую строку.

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

К таблице

См. также

• System.Globalization.NumberFormatInfo
• Типы форматирования
• Стандартные строки в числовом формате
• Практическое руководство. Добавление к числу начальных нулей
• Пример: служебная программа форматирования .NET Core WinForms (C#)
• Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)