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

Строки стандартных числовых форматов служат для форматирования стандартных числовых типов. Строка стандартных числовых форматов использует формат [format specifier][precision specifier], где:

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

  • Описатель точности — это необязательное целое число, которое влияет на число цифр в результирующей строке. В .NET 7 и более поздних версиях максимальное значение точности — 999 999 999. В .NET 6 максимальное значение точности равно Int32.MaxValue. В предыдущих версиях .NET точность может варьироваться от 0 до 99. Спецификатор точности управляет количеством цифр в строковом представлении числа. Он не округляет само число. Для выполнения операции округления используйте метод Math.Ceiling, Math.Floor или Math.Round.

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

    • В .NET Framework и .NET Core вплоть до версии 2.0 среда выполнения выбирает результат с большей наименее значащей цифрой (то есть с использованием MidpointRounding.AwayFromZero).
    • В .NET Core 2.1 и более поздних версиях среда выполнения выбирает результат с четной наименее значащей цифрой (то есть с использованием MidpointRounding.ToEven).

    Примечание

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

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

Совет

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

Описатели стандартного формата

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

Результат форматируемой строки для определенного языка и региональных параметров может отличаться от следующих примеров. Параметры операционной системы, параметры пользователя, переменные среды и используемая версия .NET могут повлиять на формат. Например, начиная с .NET 5, .NET пытается объединить культурные форматы на разных платформах. Дополнительные сведения см. в статье о глобализации .NET и ICU.

Описатель формата name Описание Примеры
"C" или "c" Валюта Результат: ; значение валюты.

Поддерживается в: все числовые типы.

Описатель точности: число десятичных разрядов.

Описатель точности по умолчанию: Определяется в NumberFormatInfo.CurrencyDecimalDigits.

Дополнительная информация: Описатель формата валюты ("C").
123.456 ("C", en-US)
-> \$123.46

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

123.456 ("C", ja-JP)
-> 123

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

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

-123.456 ("C3", ja-JP)
- -"123.456">
"D" или "d" Decimal Результат: ; целочисленные цифры с необязательным отрицательным знаком.

Поддерживается в: только целочисленные типы.

Описатель точности: минимальное число разрядов.

Описатель точности по умолчанию: минимальное требуемое число разрядов.

Дополнительная информация: Описатель десятичного формата ("D").
1234 ("D")
-> 1234

-1234 ("D6")
-> -001234
"E" или "e" Экспоненциальный (научный) Результат: ; экспоненциальная нотация.

Поддерживается в: все числовые типы.

Описатель точности: число десятичных разрядов.

Описатель точности по умолчанию: 6.

Дополнительная информация: Описатель экспоненциального формата ("E").
1052.0329112756 ("E", en-US)
-> 1.052033E+003

1052.0329112756 ("e", fr-FR)
-> 1052033e+003

-1052.0329112756 ("e2", en-US)
-> -1.05e+003

-1052.0329112756 ("E2", fr-FR)
-> -1,05E+003
"F" или "f" С фиксированной запятой Результат: ; цифры целой и дробной частей с необязательным отрицательным знаком.

Поддерживается в: все числовые типы.

Описатель точности: число десятичных разрядов.

Описатель точности по умолчанию: Определяется в NumberFormatInfo.NumberDecimalDigits.

Дополнительная информация: Описатель формата с фиксированной запятой ("F").
1234.567 ("F", en-US)
-> 1234.57

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

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

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

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

-1234.56 ("F4", de-DE)
-> -1234 5600
"G" или "g" Общее Результат: ; наиболее компактная запись из двух вариантов — экспоненциального и с фиксированной запятой.

Поддерживается в: все числовые типы.

Описатель точности: количество значащих цифр.

Описатель точности по умолчанию: зависит от числового типа.

Дополнительная информация: Описатель общего формата ("G").
-123.456 ("G", en-US)
-> -123.456

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

123.4546 ("G4", en-US)
-> 123.5

123.4546 ("G4", sv-SE)
-> 123 5

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

-1.234567890e-25 ("G", sv-SE)
-> -1,23456789E-25
"N" или "n" Число Результат: ; цифры целой и дробной частей, разделители групп и разделитель целой и дробной частей с необязательным отрицательным знаком.

Поддерживается в: все числовые типы.

Описатель точности: желаемое число десятичных разрядов.

Описатель точности по умолчанию: Определяется в NumberFormatInfo.NumberDecimalDigits.

Дополнительная информация: Описатель числового формата ("N").
1234.567 ("N", en-US)
-> 1,234,57

1234.567 ("N", ru-RU)
-> 1 234 57

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

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

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

-1234.56 ("N3", ru-RU)
-> -1 234 560
"P" или "p" Процент Результат: ; число, умноженное на 100 и отображаемое с символом процента.

Поддерживается в: все числовые типы.

Описатель точности: желаемое число десятичных разрядов.

Описатель точности по умолчанию: Определяется в NumberFormatInfo.PercentDecimalDigits.

Дополнительная информация: Описатель формата процента ("P").
1 ("P", en-US)
-> 100,00 %

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

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

-0,39678 ("P1", fr-FR)
-> -39,7 %
"R" или "r" Приемо-передача Результат: ; строка, дающая при обратном преобразовании идентичное число.

Поддерживается: Single, Double и BigInteger.

Примечание. Мы рекомендуем использовать только для типа BigInteger. Для типов Double используйте "G17", а для типов Single — "G9".
Описатель точности: Не обрабатывается.

Дополнительная информация: Описатель формата обратного преобразования ("R").
123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" или "x" Шестнадцатеричный Результат: ; шестнадцатеричная строка.

Поддерживается в: только целочисленные типы.

Описатель точности: число цифр в результирующей строке.

Дополнительная информация: Описатель шестнадцатеричного формата ("X").
255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Любой другой символ Неизвестный описатель Результат: ; порождение исключения FormatException во время выполнения.

Использование строк стандартного числового формата

Примечание

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

Строку стандартного числового формата можно использовать для определения форматирования числового значения одним из следующих способов:

  • Его можно передать методу TryFormat или перегрузке ToString метода с параметром format . В следующем примере осуществляется форматирование числового значения в качестве строки со значением валюты для текущего языка и региональных параметров (en-US).

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))
    ' Displays $123.46
    
  • Эту строку можно передать в качестве аргумента formatString в элемент форматирования, используемый с методами String.Format, Console.WriteLine и StringBuilder.AppendFormat. Дополнительные сведения см. в разделе Составное форматирование. В следующем примере элемент форматирования используется для вставки значения валюты в строку.

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    decimal value = 123.456m;
    Console.WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    Dim value As Decimal = 123.456d
    Console.WriteLine("Your account balance is {0:C2}.", value)
    ' Displays "Your account balance is $123.46."
    

    При желании вы можете передать аргумент alignment, чтобы указать ширину числового поля и установить выравнивание по правому или левому краю. В следующем примере денежное значение в поле длиной 28 символов выравнивается по левому краю, а денежное значение в поле длиной 14 символов выравнивается по правому краю.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16
    
    Dim amounts() As Decimal = {16305.32d, 18794.16d}
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Его можно предоставить в виде аргумента formatString в элементе интерполированного выражения интерполированной строки. Дополнительные сведения см. в статье о интерполяции строк в справочнике по C# или в статье интерполированных строк в справочнике по Visual Basic.

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

Описатель формата валюты (C)

При использовании описателя формата валюты ("C") число преобразуется в строку, представляющую сумму в некоторой валюте. Желаемое количество знаков дробной части в результирующей строке задается описателем точности. Если описатель точности не задан, точность по умолчанию определяется свойством NumberFormatInfo.CurrencyDecimalDigits.

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

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

Свойство NumberFormatInfo Описание
CurrencyPositivePattern Определяет положение символа валюты в положительных значениях.
CurrencyNegativePattern Определяет положение символа валюты в отрицательных значениях и указывает, как именно представляется отрицательный знак: круглыми скобками или свойством NegativeSign.
NegativeSign Задает отрицательный знак, используемый в случае, если свойство CurrencyNegativePattern указывает на то, что скобки для отрицания не используются.
CurrencySymbol Определяет символ валюты.
CurrencyDecimalDigits Определяет количество цифр дробной части в значении валюты по умолчанию. Это значение можно переопределить с помощью описателя точности.
CurrencyDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
CurrencyGroupSeparator Определяет строку, разделяющую группы цифр целой части.
CurrencyGroupSizes Определяет число целочисленных цифр, входящих в группу.

В следующем примере значение Double форматируется с помощью описателя денежного формата:

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3",
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Описатель десятичного формата (D)

При использовании описателя десятичного формата ("D") число преобразуется в строку, состоящую из десятичных цифр (0–9); если число отрицательное, перед ним ставится отрицательный знак. Этот формат доступен только для целых типов.

Минимальное количество знаков в выходной строке задается спецификатором точности. Недостающие знаки в строке заменяются нулями. Если описатель точности не задан, по умолчанию используется минимальное значение, позволяющее представить целое число без нулей в начале.

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую, что число является отрицательным.

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

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345
int value;

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Описатель экспоненциального формата (E)

При использовании описателя экспоненциального формата ("E") число преобразуется в строку вида "-d.ddd…E+ddd" или "-d.ddd…e+ddd", где каждый символ "d" обозначает цифру (0–9). Если число отрицательное, в начале строки ставится отрицательный знак. Перед разделителем целой и дробной части всегда стоит ровно одна цифра.

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

Регистр описателя формата задает регистр буквы, стоящей перед экспонентой ("E" или "e"). Экспонента состоит из знака "плюс" или "минус" и трех цифр. Недостающие до минимума цифры заменяются нулями, если это необходимо.

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую на то, что число является отрицательным (как мантисса, так и экспонента).
NumberDecimalSeparator Определяет строку, разделяющую целую и дробную части мантиссы.
PositiveSign Определяет строку, указывающую, что экспонента является положительной.

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

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Описатель формата фиксированной точки (F)

При использовании описателя формата с фиксированной запятой ("F") число преобразуется в строку вида "-ddd.ddd…", где каждый символ "d" обозначает цифру (0–9). Если число отрицательное, в начале строки ставится отрицательный знак.

Требуемое число знаков дробной части задается спецификатором точности. Если описатель точности отсутствует, то используется численная точность, определяемая текущим значением свойства NumberFormatInfo.NumberDecimalDigits.

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую, что число является отрицательным.
NumberDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
NumberDecimalDigits Определяет количество цифр дробной части по умолчанию. Это значение можно переопределить с помощью описателя точности.

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

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199                        

Описатель общего формата (G)

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

Числовой тип Точность по умолчанию
Byte или SByte 3 знака
Int16 или UInt16 5 знака
Int32 или UInt32 10 знака
Int64 19 знака
UInt64 20 знака
BigInteger Без ограничений (то же, что и R)
Half 3 знака
Single 7 знака
Double 15 знака
Decimal 29 знака

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

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

Если используется экспоненциальная нотация, регистр буквы, стоящей перед экспонентой, определяется регистром описателя формата (буква "E" соответствует "G", "e" соответствует "g"). Экспонента содержит не менее двух цифр. Это отличает данный формат от экспоненциальной записи, создаваемой при использовании описателя экспоненциального формата, поскольку в последнем случае экспонента содержит не менее трех цифр.

При использовании со Double значением описатель формата "G17" гарантирует, что исходное Double значение успешно выполняет циклический цикл. Это связано с тем, что Double это число с плавающей запятойbinary64, совместимое с IEEE 754-2008, которое дает до 17 значимых цифр точности. В платформа .NET Framework рекомендуется использовать его вместо описателя формата "R", так как в некоторых случаях "R" не удается успешно выполнить значения двойной точности с плавающей запятой.

При использовании со значением Single описатель формата G9 гарантирует обратимость преобразования исходного значения Single. Это связано с тем, что Single это число с плавающей запятой,совместимоеbinary32 с IEEE 754-2008, которое дает до девяти значимых цифр точности. Из соображений производительности рекомендуется использовать его вместо описателя формата "R".

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую, что число является отрицательным.
NumberDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
PositiveSign Определяет строку, указывающую, что экспонента является положительной.

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

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416    
double number;

number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416
Dim number As Double

number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416    

Описатель числового формата (N)

Спецификатор числового формата ("N") преобразует число в стоку вида "-d,ddd,ddd.ddd… ", где знак "-" при необходимости представляет знак отрицательного числа, знак "d" означает цифру (0-9), знак "," — разделитель групп, а знак "." —- разделитель целой и дробной части. Требуемое число знаков дробной части задается спецификатором точности. Если описатель точности не задан, число десятичных знаков определяется текущим свойством NumberFormatInfo.NumberDecimalDigits.

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую, что число является отрицательным.
NumberNegativePattern Определяет формат отрицательных значений и указывает, как именно представляется отрицательный знак: круглыми скобками или свойством NegativeSign.
NumberGroupSizes Определяет число цифр целой части, стоящих между разделителями групп.
NumberGroupSeparator Определяет строку, разделяющую группы цифр целой части.
NumberDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
NumberDecimalDigits Определяет количество цифр дробной части по умолчанию. Это значение можно переопределить с помощью описателя точности.

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

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0 

Описатель формата процента (P)

При использовании описателя формата процента ("P") число умножается на 100 и преобразуется в строку, представляющую процентную долю. Требуемое число знаков дробной части задается спецификатором точности. Если описатель точности отсутствует, то используется значение точности числа по умолчанию, заданное свойством PercentDecimalDigits.

В следующей таблице представлены свойства NumberFormatInfo, обеспечивающие управление форматированием возвращаемой строки.

Свойство NumberFormatInfo Описание
PercentPositivePattern Определяет положение символа процента в положительных значениях.
PercentNegativePattern Определяет положение символа процента и отрицательного знака в отрицательных значениях.
NegativeSign Определяет строку, указывающую, что число является отрицательным.
PercentSymbol Определяет символ процента.
PercentDecimalDigits Определяет количество цифр дробной части в значении процента по умолчанию. Это значение можно переопределить с помощью описателя точности.
PercentDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
PercentGroupSeparator Определяет строку, разделяющую группы цифр целой части.
PercentGroupSizes Определяет число целочисленных цифр, входящих в группу.

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

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Описатель формата кругового пути (R)

Описатель формата обратного преобразования ("R") пытается выполнить преобразование числового значения в строку так, чтобы при обратном преобразовании этой строки можно было получить то же самое числовое значение. Этот формат поддерживается только для Halfтипов , SingleDoubleи BigInteger ,.

В платформа .NET Framework и в версиях .NET Core, предшествующих 3.0, описатель формата "R" в некоторых случаях не сможет успешно выполнить циклический обходDouble. Для обоих Double значений Single описатель формата "R" обеспечивает относительно низкую производительность. Вместо него мы рекомендуем использовать описатель формата G17 для значений Double и описатель формата G9 для значений Single, которые гарантируют правильное обратное преобразование.

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

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

Свойство NumberFormatInfo Описание
NegativeSign Определяет строку, указывающую, что число является отрицательным.
NumberDecimalSeparator Определяет строку, разделяющую целую и дробную части числа.
PositiveSign Определяет строку, указывающую, что экспонента является положительной.

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

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249
Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249  

Важно!

В некоторых случаях для значений Double, отформатированных с использованием строки стандартного числового формата "R", не удается успешно выполнить обратное преобразование при компиляции с использованием параметра /platform:x64 или /platform:anycpu и запуска в 64-разрядных системах. Дополнительные сведения см. в следующем абзаце.

Чтобы избежать проблемы со значениями Double, отформатированными с использованием строки стандартного числового формата R, для которых не удалось выполнить обратное преобразование при компиляции с использованием параметра /platform:x64 или /platform:anycpu в 64-разрядных системах, можно отформатировать значения Double с помощью строки стандартного числового формата G17. В примере ниже используется строка формата "R" со значением Double, для которого не удается выполнить обратное преобразование, а также строка формата "G17" для успешного обратного преобразования исходного значения:

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

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

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

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

Описатель шестнадцатеричного формата (X)

При использовании описателя шестнадцатеричного формата ("X") число преобразуется в строку шестнадцатеричных цифр. Регистр шестнадцатеричных цифр больше 9 совпадает с регистром описателя формата. Например, чтобы получить запись "ABCDEF", задайте описатель X" или, наоборот, задайте описатель "x", чтобы получить "abcdef". Этот формат доступен только для целых типов.

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

Форматирование результирующей строки не зависит от сведений о форматировании в текущем объекте NumberFormatInfo.

В следующем примере значения Int32 форматируются с помощью спецификатора шестнадцатеричного формата.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15
int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Примечания

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

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

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

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

Свойства NumberFormatInfo

Форматирование зависит от свойств текущего NumberFormatInfo объекта, который предоставляется неявно текущим языком и региональными параметрами или явно параметром IFormatProvider метода, который вызывает форматирование. Укажите объект NumberFormatInfo или объект CultureInfo для этого параметра.

Примечание

Дополнительные сведения о настройке шаблонов или строк, используемых в форматировании числовых значений см. статью о классе NumberFormatInfo.

Целочисленные типы и типы с плавающей запятой

Некоторые описания спецификаторов стандартных числовых форматов относятся к целочисленным типам и типам с плавающей запятой. Целочисленные типы — это Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 и BigInteger. Числовые типы с плавающей запятой: Decimal, Halfи SingleDouble.

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

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

Пример кода

В следующем примере с помощью языка и региональных параметров "en-US" и всех описателей стандартных числовых форматов форматируется целочисленное значение и числовое значение с плавающей запятой. В этом примере используются два конкретных числовых типа (Doubleи), но будут получены аналогичные результаты для любого из других числовых базовых типов (Byte, , Int16SByte, UInt16Int64BigIntegerHalfInt32UInt32UInt64Decimalи ).SingleInt32

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

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

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

Imports System.Globalization
Imports System.Threading

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

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

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

См. также