Double.ToString Метод
Определение
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.Converts the numeric value of this instance to its equivalent string representation.
Перегрузки
| ToString(String, IFormatProvider) |
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях форматирования для данного языка и региональных параметров.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information. |
| ToString(String) |
Преобразует числовое значение данного экземпляра в эквивалентное строковое представление с использованием указанного формата.Converts the numeric value of this instance to its equivalent string representation, using the specified format. |
| ToString(IFormatProvider) |
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанных сведений об особенностях форматирования для данного языка и региональных параметров.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information. |
| ToString() |
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.Converts the numeric value of this instance to its equivalent string representation. |
ToString(String, IFormatProvider)
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях форматирования для данного языка и региональных параметров.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.
public:
virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);public string ToString (string format, IFormatProvider provider);public string? ToString (string format, IFormatProvider provider);override this.ToString : string * IFormatProvider -> stringPublic Function ToString (format As String, provider As IFormatProvider) As StringПараметры
- format
- String
Строка числового формата.A numeric format string.
- provider
- IFormatProvider
Объект, предоставляющий сведения о форматировании для определенного языка и региональных параметров.An object that supplies culture-specific formatting information.
Возвращаемое значение
Строковое представление значения данного экземпляра, определяемое параметрами format и provider.The string representation of the value of this instance as specified by format and provider.
Реализации
Примеры
В следующем примере отображается Double значение с использованием каждого из поддерживаемых стандартных описателей числового формата для нескольких различных языков и региональных параметров.The following example displays a Double value using each of the supported standard numeric format specifiers for several different cultures.
using namespace System;
using namespace System::Globalization;
int main(array<System::String ^> ^args)
{
double value = 16325.62901;
String^ specifier;
CultureInfo^ culture;
// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo::CreateSpecificCulture("eu-ES");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325,62901
Console::WriteLine(value.ToString(specifier, CultureInfo::InvariantCulture));
// Displays: 16325.62901
specifier = "C";
culture = CultureInfo::CreateSpecificCulture("en-US");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: $16,325.63
culture = CultureInfo::CreateSpecificCulture("en-GB");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: £16,325.63
specifier = "E04";
culture = CultureInfo::CreateSpecificCulture("sv-SE");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
culture = CultureInfo::CreateSpecificCulture("en-NZ");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 1.6326E+004
specifier = "F";
culture = CultureInfo::CreateSpecificCulture("fr-FR");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325,63
culture = CultureInfo::CreateSpecificCulture("en-CA");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325.63
specifier = "N";
culture = CultureInfo::CreateSpecificCulture("es-ES");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16.325,63
culture = CultureInfo::CreateSpecificCulture("fr-CA");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16 325,63
specifier = "P";
culture = CultureInfo::InvariantCulture;
Console::WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.26 %
culture = CultureInfo::CreateSpecificCulture("ar-EG");
Console::WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.256 %
return 0;
}
double value = 16325.62901;
string specifier;
CultureInfo culture;
// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays: 16325.62901
specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: £16,325.63
specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
culture = CultureInfo.CreateSpecificCulture("en-NZ");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1.6326E+004
specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325.63
specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16 325,63
specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.256 %
Dim value As Double = 16325.62901
Dim specifier As String
Dim culture As CultureInfo
' Use standard numeric format specifiers.
specifier = "G"
culture = CultureInfo.CreateSpecificCulture("eu-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture))
' Displays: 16325.62901
specifier = "C"
culture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: £16,325.63
specifier = "E04"
culture = CultureInfo.CreateSpecificCulture("sv-SE")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1,6326E+004
culture = CultureInfo.CreateSpecificCulture("en-NZ")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1.6326E+004
specifier = "F"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325.63
specifier = "N"
culture = CultureInfo.CreateSpecificCulture("es-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16 325,63
specifier = "P"
culture = CultureInfo.InvariantCulture
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays: 163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG")
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays: 163.256 %
В следующем примере показано использование ToString , принимающее String IFormatProvider Параметры и.The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.
public ref class Temperature: public IFormattable
{
// IFormattable.ToString implementation.
public:
virtual String^ ToString( String^ format, IFormatProvider^ provider )
{
if ( format != nullptr )
{
if ( format->Equals( "F" ) )
{
return String::Format( "{0}'F", this->Value.ToString() );
}
if ( format->Equals( "C" ) )
{
return String::Format( "{0}'C", this->Celsius.ToString() );
}
}
return m_value.ToString( format, provider );
}
protected:
// The value holder
double m_value;
public:
property double Value
{
double get()
{
return m_value;
}
void set( double value )
{
m_value = value;
}
}
property double Celsius
{
double get()
{
return (m_value - 32.0) / 1.8;
}
void set( double value )
{
m_value = 1.8 * value + 32.0;
}
}
};
public class Temperature : IFormattable {
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
Public Class Temperature
Implements IFormattable
Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
Implements IFormattable.ToString
If Not (format Is Nothing) Then
If format.Equals("F") Then
Return [String].Format("{0}'F", Me.Value.ToString())
End If
If format.Equals("C") Then
Return [String].Format("{0}'C", Me.Celsius.ToString())
End If
End If
Return m_value.ToString(format, provider)
End Function
' The value holder
Protected m_value As Double
Public Property Value() As Double
Get
Return m_value
End Get
Set(ByVal Value As Double)
m_value = Value
End Set
End Property
Public Property Celsius() As Double
Get
Return (m_value - 32) / 1.8
End Get
Set(ByVal Value As Double)
m_value = Value * 1.8 + 32
End Set
End Property
End Class
Комментарии
ToString(String, IFormatProvider)Метод форматирует Double значение в указанном формате указанного языка и региональных параметров.The ToString(String, IFormatProvider) method formats a Double value in a specified format of a specified culture. Если необходимо указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| Использование форматаTo use format | Для языка и региональных параметровFor culture | Использование перегрузкиUse the overload |
|---|---|---|
| Формат по умолчанию ("G")Default ("G") format | Культура по умолчанию (текущий)Default (current) culture | ToString() |
| Формат по умолчанию ("G")Default ("G") format | Конкретный язык и региональные параметрыA specific culture | ToString(IFormatProvider) |
| Конкретный формат или точностьA specific format or precision | Культура по умолчанию (текущий)Default (current) culture | ToString(String) |
Возвращаемое значение может быть PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol или строковым представлением числа, как указано в format .The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.
formatПараметр может быть любым допустимым описателем стандартного числового формата, за исключением D и X, а также любого сочетания настраиваемых описателей числового формата.The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. Если format параметр имеет null значение или является пустой строкой, то возвращаемые значения для этого экземпляра форматируются с помощью описателя общего числового формата ("G").If format is null or an empty string, the return value for this instance is formatted with the general numeric format specifier ("G").
.NET Framework обеспечивает обширную поддержку форматирования, которая подробно описана в следующих разделах форматирования:The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:
Дополнительные сведения о спецификаторах числовых форматов см. в разделе строки стандартных числовых форматов и строки настраиваемых числовых форматов.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Дополнительные сведения о форматировании см. в разделе Типы форматирования.For more information about formatting, see Formatting Types.
providerПараметр — это IFormatProvider реализация, GetFormat метод которой возвращает NumberFormatInfo объект.The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. Как правило, provider является CultureInfo объектом или NumberFormatInfo объектом.Typically, provider is a CultureInfo object or a NumberFormatInfo object. providerПараметр предоставляет сведения о языке и региональных параметрах, используемые при форматировании.The provider parameter supplies culture-specific information used in formatting. Если provider параметр имеет null значение, возвращаемые значения форматируются с использованием NumberFormatInfo объекта для текущего языка и региональных параметров.If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.
По умолчанию возвращаемое значение содержит только 15 цифр точности, хотя для внутренних целей поддерживается не более 17 цифр.By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. Если значение этого экземпляра превышает 15 цифр, ToString возвращает PositiveInfinitySymbol или NegativeInfinitySymbol вместо ожидаемого числа.If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. Если требуется дополнительная точность, укажите format с помощью спецификации формата "G17", которая всегда возвращает 17 разрядов точности, или "R", который возвращает 15 цифр, если число может быть представлено с точностью, равное 17, если число может быть представлено только с максимальной точностью.If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.
Примечания для тех, кто вызывает этот метод
В некоторых случаях для значений Double, отформатированных с использованием строки стандартного числового формата "R", не удается успешно выполнить обратное преобразование при компиляции с использованием параметра /platform:x64 или /platform:anycpu и запуска в 64-разрядных системах.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Чтобы обойти эту проблему, можно форматировать значения Double с помощью строки стандартного числового формата "G17".To work around this problem, you can format Double values by using the "G17" standard numeric format string. В примере ниже используется строка формата "R" со значением Double, для которого не удается выполнить обратное преобразование, а также строка формата "G17" для успешного обратного преобразования исходного значения.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.
::: код Language = "CSharp" Source = "~/самплес/сниппетс/кшарп/VS_Snippets_CLR_System/систем. Double. ToString/CS/roundtripex1. CS «Interactive =» try-DotNet» ID = "Snippet5":::::: Code Language = "VB" Source = "~/самплес/сниппетс/висуалбасик/VS_Snippets_CLR_System/систем. Double. ToString/VB/roundtripex1. vb "ID =" Snippet5 "::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.Double.ToString/cs/roundtripex1.cs" interactive="try-dotnet" id="Snippet5"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.Double.ToString/vb/roundtripex1.vb" id="Snippet5":::
См. также раздел
- Parse(String)
- Типы форматирования в .NETFormatting Types in .NET
- Строки стандартных числовых форматовStandard Numeric Format Strings
- Строки настраиваемых числовых форматовCustom Numeric Format Strings
- Практическое руководство. Добавление к числу начальных нулей.How to: Pad a Number with Leading Zeros
- Пример: служебная программа форматирования .NET Core WinForms (C#)Sample: .NET Core WinForms Formatting Utility (C#)
- Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)Sample: .NET Core WinForms Formatting Utility (Visual Basic)
Применяется к
ToString(String)
Преобразует числовое значение данного экземпляра в эквивалентное строковое представление с использованием указанного формата.Converts the numeric value of this instance to its equivalent string representation, using the specified format.
public:
System::String ^ ToString(System::String ^ format);public string ToString (string format);public string ToString (string? format);override this.ToString : string -> stringPublic Function ToString (format As String) As StringПараметры
- format
- String
Строка числового формата.A numeric format string.
Возвращаемое значение
Строковое представление значения данного экземпляра, определяемое параметром format.The string representation of the value of this instance as specified by format.
Исключения
format недопустим.format is invalid.
Примеры
В следующем примере определяется числовое значение и форматируется как денежное значение с помощью строки стандартного числового формата "C", а в качестве числового значения для трех десятичных разрядов используется строка стандартного числового формата "N".The following example defines a numeric value and formats it as a currency value by using the "C" standard numeric format string and as a numeric value to three decimal places by using the "N" standard numeric format string. Строки результатов форматируются с помощью соглашений языка и региональных параметров en-US.The result strings are formatted by using the conventions of the en-US culture. Дополнительные сведения о строках числового формата см. в разделе строки стандартных числовых форматов и строки настраиваемых числовых форматов.For more information on numeric format strings, see Standard Numeric Format Strings and Custom Numeric Format Strings.
using System;
public class Example
{
public static void Main()
{
float number = 1764.3789m;
// Format as a currency value.
Console.WriteLine(number.ToString("C"));
// Format as a numeric value with 3 decimal places.
Console.WriteLine(number.ToString("N3"));
}
}
// The example displays the following output:
// $1,764.38
// 1,764.379
Module Example
Public Sub Main()
Dim number As Double = 1764.3789
' Format as a currency value.
Console.WriteLine(number.ToString("C"))
' Format as a numeric value with 3 decimal places.
Console.WriteLine(number.ToString("N3"))
End Sub
End Module
' The example displays the following output:
' $1,764.38
' 1,764.379
В следующем примере показано несколько Double значений с использованием поддерживаемых стандартных описателей числового формата вместе с тремя строками настраиваемого числового формата.The following example displays several Double values using the supported standard numeric format specifiers together with three custom numeric format strings. Одна из этих строк настраиваемого формата показывает, как заполнить Single значение начальными нулями.One of those custom format strings illustrates how to pad a Single value with leading zeros. Кроме того, в примере используются описатели точности с каждым описателем стандартного формата, за исключением "R".In addition, the example uses precision specifiers with each standard format specifier except for "R". Значения описателей точности находятся в диапазоне от 0 до 3.The values of the precision specifiers range from 0 to 3. Чтобы преобразовать числовые значения в строки, в примере используются соглашения о форматировании для языка и региональных параметров en-US.To convert the numeric values to strings, the example uses the formatting conventions of the en-US culture.
using namespace System;
void main()
{
array<Double>^ numbers= {1054.32179, -195489100.8377, 1.0437E21,
-1.0573e-05};
array<String^>^ specifiers = { "C", "E", "e", "F", "G", "N", "P",
"R", "#,000.000", "0.###E-000",
"000,000,000,000.00###" };
for each (Double number in numbers)
{
Console::WriteLine("Formatting of {0}:", number);
for each (String^ specifier in specifiers) {
Console::WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier));
// Add precision specifiers from 0 to 3.
if (specifier->Length == 1 & ! specifier->Equals("R")) {
for (int precision = 0; precision <= 3; precision++) {
String^ pSpecifier = String::Format("{0}{1}", specifier, precision);
Console::WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier));
}
Console::WriteLine();
}
}
Console::WriteLine();
}
}
// The example displays the following output:
// Formatting of 1054.32179:
// C: $1,054.32
// C0: $1,054
// C1: $1,054.3
// C2: $1,054.32
// C3: $1,054.322
//
// E: 1.054322E+003
// E0: 1E+003
// E1: 1.1E+003
// E2: 1.05E+003
// E3: 1.054E+003
//
// e: 1.054322e+003
// e0: 1e+003
// e1: 1.1e+003
// e2: 1.05e+003
// e3: 1.054e+003
//
// F: 1054.32
// F0: 1054
// F1: 1054.3
// F2: 1054.32
// F3: 1054.322
//
// G: 1054.32179
// G0: 1054.32179
// G1: 1E+03
// G2: 1.1E+03
// G3: 1.05E+03
//
// N: 1,054.32
// N0: 1,054
// N1: 1,054.3
// N2: 1,054.32
// N3: 1,054.322
//
// P: 105,432.18 %
// P0: 105,432 %
// P1: 105,432.2 %
// P2: 105,432.18 %
// P3: 105,432.179 %
//
// R: 1054.32179
// #,000.000: 1,054.322
// 0.###E-000: 1.054E003
// 000,000,000,000.00###: 000,000,001,054.32179
//
// Formatting of -195489100.8377:
// C: ($195,489,100.84)
// C0: ($195,489,101)
// C1: ($195,489,100.8)
// C2: ($195,489,100.84)
// C3: ($195,489,100.838)
//
// E: -1.954891E+008
// E0: -2E+008
// E1: -2.0E+008
// E2: -1.95E+008
// E3: -1.955E+008
//
// e: -1.954891e+008
// e0: -2e+008
// e1: -2.0e+008
// e2: -1.95e+008
// e3: -1.955e+008
//
// F: -195489100.84
// F0: -195489101
// F1: -195489100.8
// F2: -195489100.84
// F3: -195489100.838
//
// G: -195489100.8377
// G0: -195489100.8377
// G1: -2E+08
// G2: -2E+08
// G3: -1.95E+08
//
// N: -195,489,100.84
// N0: -195,489,101
// N1: -195,489,100.8
// N2: -195,489,100.84
// N3: -195,489,100.838
//
// P: -19,548,910,083.77 %
// P0: -19,548,910,084 %
// P1: -19,548,910,083.8 %
// P2: -19,548,910,083.77 %
// P3: -19,548,910,083.770 %
//
// R: -195489100.8377
// #,000.000: -195,489,100.838
// 0.###E-000: -1.955E008
// 000,000,000,000.00###: -000,195,489,100.8377
//
// Formatting of 1.0437E+21:
// C: $1,043,700,000,000,000,000,000.00
// C0: $1,043,700,000,000,000,000,000
// C1: $1,043,700,000,000,000,000,000.0
// C2: $1,043,700,000,000,000,000,000.00
// C3: $1,043,700,000,000,000,000,000.000
//
// E: 1.043700E+021
// E0: 1E+021
// E1: 1.0E+021
// E2: 1.04E+021
// E3: 1.044E+021
//
// e: 1.043700e+021
// e0: 1e+021
// e1: 1.0e+021
// e2: 1.04e+021
// e3: 1.044e+021
//
// F: 1043700000000000000000.00
// F0: 1043700000000000000000
// F1: 1043700000000000000000.0
// F2: 1043700000000000000000.00
// F3: 1043700000000000000000.000
//
// G: 1.0437E+21
// G0: 1.0437E+21
// G1: 1E+21
// G2: 1E+21
// G3: 1.04E+21
//
// N: 1,043,700,000,000,000,000,000.00
// N0: 1,043,700,000,000,000,000,000
// N1: 1,043,700,000,000,000,000,000.0
// N2: 1,043,700,000,000,000,000,000.00
// N3: 1,043,700,000,000,000,000,000.000
//
// P: 104,370,000,000,000,000,000,000.00 %
// P0: 104,370,000,000,000,000,000,000 %
// P1: 104,370,000,000,000,000,000,000.0 %
// P2: 104,370,000,000,000,000,000,000.00 %
// P3: 104,370,000,000,000,000,000,000.000 %
//
// R: 1.0437E+21
// #,000.000: 1,043,700,000,000,000,000,000.000
// 0.###E-000: 1.044E021
// 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
// Formatting of -1.0573E-05:
// C: $0.00
// C0: $0
// C1: $0.0
// C2: $0.00
// C3: $0.000
//
// E: -1.057300E-005
// E0: -1E-005
// E1: -1.1E-005
// E2: -1.06E-005
// E3: -1.057E-005
//
// e: -1.057300e-005
// e0: -1e-005
// e1: -1.1e-005
// e2: -1.06e-005
// e3: -1.057e-005
//
// F: 0.00
// F0: 0
// F1: 0.0
// F2: 0.00
// F3: 0.000
//
// G: -1.0573E-05
// G0: -1.0573E-05
// G1: -1E-05
// G2: -1.1E-05
// G3: -1.06E-05
//
// N: 0.00
// N0: 0
// N1: 0.0
// N2: 0.00
// N3: 0.000
//
// P: 0.00 %
// P0: 0 %
// P1: 0.0 %
// P2: 0.00 %
// P3: -0.001 %
//
// R: -1.0573E-05
// #,000.000: 000.000
// 0.###E-000: -1.057E-005
// 000,000,000,000.00###: -000,000,000,000.00001
double[] numbers= {1054.32179, -195489100.8377, 1.0437E21,
-1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P",
"R", "#,000.000", "0.###E-000",
"000,000,000,000.00###" };
foreach (double number in numbers)
{
Console.WriteLine("Formatting of {0}:", number);
foreach (string specifier in specifiers) {
Console.WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier));
// Add precision specifiers from 0 to 3.
if (specifier.Length == 1 & ! specifier.Equals("R")) {
for (int precision = 0; precision <= 3; precision++) {
string pSpecifier = String.Format("{0}{1}", specifier, precision);
Console.WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier));
}
Console.WriteLine();
}
}
Console.WriteLine();
}
// The example displays the following output to the console:
// Formatting of 1054.32179:
// C: $1,054.32
// C0: $1,054
// C1: $1,054.3
// C2: $1,054.32
// C3: $1,054.322
//
// E: 1.054322E+003
// E0: 1E+003
// E1: 1.1E+003
// E2: 1.05E+003
// E3: 1.054E+003
//
// e: 1.054322e+003
// e0: 1e+003
// e1: 1.1e+003
// e2: 1.05e+003
// e3: 1.054e+003
//
// F: 1054.32
// F0: 1054
// F1: 1054.3
// F2: 1054.32
// F3: 1054.322
//
// G: 1054.32179
// G0: 1054.32179
// G1: 1E+03
// G2: 1.1E+03
// G3: 1.05E+03
//
// N: 1,054.32
// N0: 1,054
// N1: 1,054.3
// N2: 1,054.32
// N3: 1,054.322
//
// P: 105,432.18 %
// P0: 105,432 %
// P1: 105,432.2 %
// P2: 105,432.18 %
// P3: 105,432.179 %
//
// R: 1054.32179
// #,000.000: 1,054.322
// 0.###E-000: 1.054E003
// 000,000,000,000.00###: 000,000,001,054.32179
//
// Formatting of -195489100.8377:
// C: ($195,489,100.84)
// C0: ($195,489,101)
// C1: ($195,489,100.8)
// C2: ($195,489,100.84)
// C3: ($195,489,100.838)
//
// E: -1.954891E+008
// E0: -2E+008
// E1: -2.0E+008
// E2: -1.95E+008
// E3: -1.955E+008
//
// e: -1.954891e+008
// e0: -2e+008
// e1: -2.0e+008
// e2: -1.95e+008
// e3: -1.955e+008
//
// F: -195489100.84
// F0: -195489101
// F1: -195489100.8
// F2: -195489100.84
// F3: -195489100.838
//
// G: -195489100.8377
// G0: -195489100.8377
// G1: -2E+08
// G2: -2E+08
// G3: -1.95E+08
//
// N: -195,489,100.84
// N0: -195,489,101
// N1: -195,489,100.8
// N2: -195,489,100.84
// N3: -195,489,100.838
//
// P: -19,548,910,083.77 %
// P0: -19,548,910,084 %
// P1: -19,548,910,083.8 %
// P2: -19,548,910,083.77 %
// P3: -19,548,910,083.770 %
//
// R: -195489100.8377
// #,000.000: -195,489,100.838
// 0.###E-000: -1.955E008
// 000,000,000,000.00###: -000,195,489,100.8377
//
// Formatting of 1.0437E+21:
// C: $1,043,700,000,000,000,000,000.00
// C0: $1,043,700,000,000,000,000,000
// C1: $1,043,700,000,000,000,000,000.0
// C2: $1,043,700,000,000,000,000,000.00
// C3: $1,043,700,000,000,000,000,000.000
//
// E: 1.043700E+021
// E0: 1E+021
// E1: 1.0E+021
// E2: 1.04E+021
// E3: 1.044E+021
//
// e: 1.043700e+021
// e0: 1e+021
// e1: 1.0e+021
// e2: 1.04e+021
// e3: 1.044e+021
//
// F: 1043700000000000000000.00
// F0: 1043700000000000000000
// F1: 1043700000000000000000.0
// F2: 1043700000000000000000.00
// F3: 1043700000000000000000.000
//
// G: 1.0437E+21
// G0: 1.0437E+21
// G1: 1E+21
// G2: 1E+21
// G3: 1.04E+21
//
// N: 1,043,700,000,000,000,000,000.00
// N0: 1,043,700,000,000,000,000,000
// N1: 1,043,700,000,000,000,000,000.0
// N2: 1,043,700,000,000,000,000,000.00
// N3: 1,043,700,000,000,000,000,000.000
//
// P: 104,370,000,000,000,000,000,000.00 %
// P0: 104,370,000,000,000,000,000,000 %
// P1: 104,370,000,000,000,000,000,000.0 %
// P2: 104,370,000,000,000,000,000,000.00 %
// P3: 104,370,000,000,000,000,000,000.000 %
//
// R: 1.0437E+21
// #,000.000: 1,043,700,000,000,000,000,000.000
// 0.###E-000: 1.044E021
// 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
// Formatting of -1.0573E-05:
// C: $0.00
// C0: $0
// C1: $0.0
// C2: $0.00
// C3: $0.000
//
// E: -1.057300E-005
// E0: -1E-005
// E1: -1.1E-005
// E2: -1.06E-005
// E3: -1.057E-005
//
// e: -1.057300e-005
// e0: -1e-005
// e1: -1.1e-005
// e2: -1.06e-005
// e3: -1.057e-005
//
// F: 0.00
// F0: 0
// F1: 0.0
// F2: 0.00
// F3: 0.000
//
// G: -1.0573E-05
// G0: -1.0573E-05
// G1: -1E-05
// G2: -1.1E-05
// G3: -1.06E-05
//
// N: 0.00
// N0: 0
// N1: 0.0
// N2: 0.00
// N3: 0.000
//
// P: 0.00 %
// P0: 0 %
// P1: 0.0 %
// P2: 0.00 %
// P3: -0.001 %
//
// R: -1.0573E-05
// #,000.000: 000.000
// 0.###E-000: -1.057E-005
// 000,000,000,000.00###: -000,000,000,000.00001
Dim numbers() As Double = {1054.32179, -195489100.8377, 1.0437E21, _
-1.0573e-05}
Dim specifiers() As String = { "C", "E", "e", "F", "G", "N", "P", _
"R", "#,000.000", "0.###E-000", _
"000,000,000,000.00###" }
For Each number As Double In numbers
Console.WriteLine("Formatting of {0}:", number)
For Each specifier As String In specifiers
Console.WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier))
' Add precision specifiers from 0 to 3.
If specifier.Length = 1 And Not specifier.Equals("R") Then
For precision As Integer = 0 To 3
Dim pSpecifier As String = String.Format("{0}{1}", specifier, precision)
Console.WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier))
Next
Console.WriteLine()
End If
Next
Console.WriteLine()
Next
' The example displays the following output:
' Formatting of 1054.32179:
' C: $1,054.32
' C0: $1,054
' C1: $1,054.3
' C2: $1,054.32
' C3: $1,054.322
'
' E: 1.054322E+003
' E0: 1E+003
' E1: 1.1E+003
' E2: 1.05E+003
' E3: 1.054E+003
'
' e: 1.054322e+003
' e0: 1e+003
' e1: 1.1e+003
' e2: 1.05e+003
' e3: 1.054e+003
'
' F: 1054.32
' F0: 1054
' F1: 1054.3
' F2: 1054.32
' F3: 1054.322
'
' G: 1054.32179
' G0: 1054.32179
' G1: 1E+03
' G2: 1.1E+03
' G3: 1.05E+03
'
' N: 1,054.32
' N0: 1,054
' N1: 1,054.3
' N2: 1,054.32
' N3: 1,054.322
'
' P: 105,432.18 %
' P0: 105,432 %
' P1: 105,432.2 %
' P2: 105,432.18 %
' P3: 105,432.179 %
'
' R: 1054.32179
' #,000.000: 1,054.322
' 0.###E-000: 1.054E003
' 000,000,000,000.00###: 000,000,001,054.32179
'
' Formatting of -195489100.8377:
' C: ($195,489,100.84)
' C0: ($195,489,101)
' C1: ($195,489,100.8)
' C2: ($195,489,100.84)
' C3: ($195,489,100.838)
'
' E: -1.954891E+008
' E0: -2E+008
' E1: -2.0E+008
' E2: -1.95E+008
' E3: -1.955E+008
'
' e: -1.954891e+008
' e0: -2e+008
' e1: -2.0e+008
' e2: -1.95e+008
' e3: -1.955e+008
'
' F: -195489100.84
' F0: -195489101
' F1: -195489100.8
' F2: -195489100.84
' F3: -195489100.838
'
' G: -195489100.8377
' G0: -195489100.8377
' G1: -2E+08
' G2: -2E+08
' G3: -1.95E+08
'
' N: -195,489,100.84
' N0: -195,489,101
' N1: -195,489,100.8
' N2: -195,489,100.84
' N3: -195,489,100.838
'
' P: -19,548,910,083.77 %
' P0: -19,548,910,084 %
' P1: -19,548,910,083.8 %
' P2: -19,548,910,083.77 %
' P3: -19,548,910,083.770 %
'
' R: -195489100.8377
' #,000.000: -195,489,100.838
' 0.###E-000: -1.955E008
' 000,000,000,000.00###: -000,195,489,100.8377
'
' Formatting of 1.0437E+21:
' C: $1,043,700,000,000,000,000,000.00
' C0: $1,043,700,000,000,000,000,000
' C1: $1,043,700,000,000,000,000,000.0
' C2: $1,043,700,000,000,000,000,000.00
' C3: $1,043,700,000,000,000,000,000.000
'
' E: 1.043700E+021
' E0: 1E+021
' E1: 1.0E+021
' E2: 1.04E+021
' E3: 1.044E+021
'
' e: 1.043700e+021
' e0: 1e+021
' e1: 1.0e+021
' e2: 1.04e+021
' e3: 1.044e+021
'
' F: 1043700000000000000000.00
' F0: 1043700000000000000000
' F1: 1043700000000000000000.0
' F2: 1043700000000000000000.00
' F3: 1043700000000000000000.000
'
' G: 1.0437E+21
' G0: 1.0437E+21
' G1: 1E+21
' G2: 1E+21
' G3: 1.04E+21
'
' N: 1,043,700,000,000,000,000,000.00
' N0: 1,043,700,000,000,000,000,000
' N1: 1,043,700,000,000,000,000,000.0
' N2: 1,043,700,000,000,000,000,000.00
' N3: 1,043,700,000,000,000,000,000.000
'
' P: 104,370,000,000,000,000,000,000.00 %
' P0: 104,370,000,000,000,000,000,000 %
' P1: 104,370,000,000,000,000,000,000.0 %
' P2: 104,370,000,000,000,000,000,000.00 %
' P3: 104,370,000,000,000,000,000,000.000 %
'
' R: 1.0437E+21
' #,000.000: 1,043,700,000,000,000,000,000.000
' 0.###E-000: 1.044E021
' 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
'
' Formatting of -1.0573E-05:
' C: $0.00
' C0: $0
' C1: $0.0
' C2: $0.00
' C3: $0.000
'
' E: -1.057300E-005
' E0: -1E-005
' E1: -1.1E-005
' E2: -1.06E-005
' E3: -1.057E-005
'
' e: -1.057300e-005
' e0: -1e-005
' e1: -1.1e-005
' e2: -1.06e-005
' e3: -1.057e-005
'
' F: 0.00
' F0: 0
' F1: 0.0
' F2: 0.00
' F3: 0.000
'
' G: -1.0573E-05
' G0: -1.0573E-05
' G1: -1E-05
' G2: -1.1E-05
' G3: -1.06E-05
'
' N: 0.00
' N0: 0
' N1: 0.0
' N2: 0.00
' N3: 0.000
'
' P: 0.00 %
' P0: 0 %
' P1: 0.0 %
' P2: 0.00 %
' P3: -0.001 %
'
' R: -1.0573E-05
' #,000.000: 000.000
' 0.###E-000: -1.057E-005
' 000,000,000,000.00###: -000,000,000,000.00001
Комментарии
ToString(String)Метод форматирует Double значение в указанном формате, используя правила текущего языка и региональных параметров.The ToString(String) method formats a Double value in a specified format by using the conventions of the current culture. Если необходимо указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| Использование форматаTo use format | Для языка и региональных параметровFor culture | Использование перегрузкиUse the overload |
|---|---|---|
| Формат по умолчанию ("G")Default ("G") format | Культура по умолчанию (текущий)Default (current) culture | ToString() |
| Формат по умолчанию ("G")Default ("G") format | Конкретный язык и региональные параметрыA specific culture | ToString(IFormatProvider) |
| Конкретный формат или точностьA specific format or precision | Конкретный язык и региональные параметрыA specific culture | ToString(String, IFormatProvider) |
Возвращаемое значение может быть PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol или строковым представлением числа, как указано в format .The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.
formatПараметр может быть любым допустимым описателем стандартного числового формата, за исключением D и X, а также любого сочетания настраиваемых описателей числового формата.The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. Если format параметр имеет null значение или является пустой строкой, возвращаемые значения форматируются с помощью описателя общего числового формата ("G").If format is null or an empty string, the return value is formatted with the general numeric format specifier ("G").
.NET Framework обеспечивает обширную поддержку форматирования, которая подробно описана в следующих разделах форматирования:The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:
Дополнительные сведения о спецификаторах числовых форматов см. в разделе строки стандартных числовых форматов и строки настраиваемых числовых форматов.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Дополнительные сведения о форматировании см. в разделе Типы форматирования.For more information about formatting, see Formatting Types.
По умолчанию возвращаемое значение содержит только 15 цифр точности, хотя для внутренних целей поддерживается не более 17 цифр.By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. Если значение этого экземпляра превышает 15 цифр, ToString возвращает PositiveInfinitySymbol или NegativeInfinitySymbol вместо ожидаемого числа.If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. Если требуется дополнительная точность, укажите format с помощью спецификации формата "G17", которая всегда возвращает 17 разрядов точности, или "R", который возвращает 15 цифр, если число может быть представлено с точностью, равное 17, если число может быть представлено только с максимальной точностью.If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.
Примечания для тех, кто вызывает этот метод
В некоторых случаях для значений Double, отформатированных с использованием строки стандартного числового формата "R", не удается успешно выполнить обратное преобразование при компиляции с использованием параметра /platform:x64 или /platform:anycpu и запуска в 64-разрядных системах.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Чтобы обойти эту проблему, можно форматировать значения Double с помощью строки стандартного числового формата "G17".To work around this problem, you can format Double values by using the "G17" standard numeric format string. В примере ниже используется строка формата "R" со значением Double, для которого не удается выполнить обратное преобразование, а также строка формата "G17" для успешного обратного преобразования исходного значения.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.
::: код Language = "CSharp" Source = "~/самплес/сниппетс/кшарп/VS_Snippets_CLR_System/систем. Double. ToString/CS/roundtripex2. CS «Interactive =» try-DotNet» ID = "Snippet6":::::: Code Language = "VB" Source = "~/самплес/сниппетс/висуалбасик/VS_Snippets_CLR_System/систем. Double. ToString/VB/roundtripex2. vb "ID =" Snippet6 "::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.Double.ToString/cs/roundtripex2.cs" interactive="try-dotnet" id="Snippet6"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.Double.ToString/vb/roundtripex2.vb" id="Snippet6":::
См. также раздел
- Parse(String)
- Типы форматирования в .NETFormatting Types in .NET
- Строки стандартных числовых форматовStandard Numeric Format Strings
- Строки настраиваемых числовых форматовCustom Numeric Format Strings
- Практическое руководство. Добавление к числу начальных нулей.How to: Pad a Number with Leading Zeros
Применяется к
ToString(IFormatProvider)
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанных сведений об особенностях форматирования для данного языка и региональных параметров.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.
public:
virtual System::String ^ ToString(IFormatProvider ^ provider);public:
System::String ^ ToString(IFormatProvider ^ provider);public string ToString (IFormatProvider provider);public string ToString (IFormatProvider? provider);override this.ToString : IFormatProvider -> stringPublic Function ToString (provider As IFormatProvider) As StringПараметры
- provider
- IFormatProvider
Объект, предоставляющий сведения о форматировании для определенного языка и региональных параметров.An object that supplies culture-specific formatting information.
Возвращаемое значение
Строковое представление значения данного экземпляра, определяемое параметром provider.The string representation of the value of this instance as specified by provider.
Реализации
Примеры
В следующем примере показано строковое представление двух Double значений с помощью CultureInfo объектов, представляющих различные языки и региональные параметры.The following example displays the string representation of two Double values using CultureInfo objects that represent several different cultures.
double value;
value = -16325.62015;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
value = 16034.125E21;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
// -16325.62015
// -16325.62015
// -16325,62015
// 1.6034125E+25
// 1.6034125E+25
// 1,6034125E+25
Dim value As Double
value = -16325.62015
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
value = 16034.125E21
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
' -16325.62015
' -16325.62015
' -16325,62015
' 1.6034125E+25
' 1.6034125E+25
' 1,6034125E+25
В следующем примере показано использование ToString , принимающее String IFormatProvider Параметры и.The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.
public ref class Temperature: public IFormattable
{
// IFormattable.ToString implementation.
public:
virtual String^ ToString( String^ format, IFormatProvider^ provider )
{
if ( format != nullptr )
{
if ( format->Equals( "F" ) )
{
return String::Format( "{0}'F", this->Value.ToString() );
}
if ( format->Equals( "C" ) )
{
return String::Format( "{0}'C", this->Celsius.ToString() );
}
}
return m_value.ToString( format, provider );
}
protected:
// The value holder
double m_value;
public:
property double Value
{
double get()
{
return m_value;
}
void set( double value )
{
m_value = value;
}
}
property double Celsius
{
double get()
{
return (m_value - 32.0) / 1.8;
}
void set( double value )
{
m_value = 1.8 * value + 32.0;
}
}
};
public class Temperature : IFormattable {
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
Public Class Temperature
Implements IFormattable
Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
Implements IFormattable.ToString
If Not (format Is Nothing) Then
If format.Equals("F") Then
Return [String].Format("{0}'F", Me.Value.ToString())
End If
If format.Equals("C") Then
Return [String].Format("{0}'C", Me.Celsius.ToString())
End If
End If
Return m_value.ToString(format, provider)
End Function
' The value holder
Protected m_value As Double
Public Property Value() As Double
Get
Return m_value
End Get
Set(ByVal Value As Double)
m_value = Value
End Set
End Property
Public Property Celsius() As Double
Get
Return (m_value - 32) / 1.8
End Get
Set(ByVal Value As Double)
m_value = Value * 1.8 + 32
End Set
End Property
End Class
Комментарии
ToString(IFormatProvider)Метод форматирует Double значение в формате по умолчанию ("G" или "общий") указанного языка и региональных параметров.The ToString(IFormatProvider) method formats a Double value in the default ("G", or general) format of a specified culture. Если необходимо указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| Использование форматаTo use format | Для языка и региональных параметровFor culture | Использование перегрузкиUse the overload |
|---|---|---|
| Формат по умолчанию ("G")Default ("G") format | По умолчанию (текущий)Default (current) | ToString() |
| Конкретный формат или точностьA specific format or precision | Культура по умолчанию (текущий)Default (current) culture | ToString(String) |
| Конкретный формат или точностьA specific format or precision | Конкретный язык и региональные параметрыA specific culture | ToString(String, IFormatProvider) |
Возвращаемое значение может быть PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol или строкой вида:The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:
[знак] целочисленные цифры [. [ дробные цифры]] [E [знак] экспоненциальные цифры][sign]integral-digits[.[fractional-digits]][E[sign]exponential-digits]
Необязательные элементы заключены в квадратные скобки ([и]).Optional elements are framed in square brackets ([ and ]). Элементы, содержащие термин "цифры", состоят из ряда числовых символов в диапазоне от 0 до 9.Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. Поддерживаются элементы, перечисленные в следующей таблице.The elements listed in the following table are supported.
| ЭлементElement | ОписаниеDescription |
|---|---|
| signsign | Знак отрицательного или положительного знака.A negative sign or positive sign symbol. |
| целые числаintegral-digits | Последовательность цифр, указывающих целую часть числа.A series of digits specifying the integral part of the number. Целочисленные цифры могут отсутствовать, если есть дробные разряды.Integral-digits can be absent if there are fractional-digits. |
| '.''.' | Символ десятичной запятой, зависящий от языка и региональных параметров.A culture-specific decimal point symbol. |
| Дробные разрядыfractional-digits | Последовательность цифр, указывающая дробную часть числа.A series of digits specifying the fractional part of the number. |
| "E"'E' | Символ верхнего регистра "E", указывающий экспоненциальную (экспоненциальную) нотацию.An uppercase character 'E', indicating exponential (scientific) notation. |
| экспоненциальные цифрыexponential-digits | Последовательность цифр, указывающая показатель степени.A series of digits specifying an exponent. |
Примеры возвращаемых значений: "100", "-123 456 789", "123,45 E + 6", "500", "3,1416", "600", "-0,123" и "-Infinity".Some examples of the return value are "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", and "-Infinity".
Этот экземпляр форматируется с помощью описателя общего числового формата ("G").This instance is formatted with the general numeric format specifier ("G").
.NET Framework обеспечивает обширную поддержку форматирования, которая подробно описана в следующих разделах форматирования:The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:
Дополнительные сведения о спецификаторах числовых форматов см. в разделе строки стандартных числовых форматов и строки настраиваемых числовых форматов.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Дополнительные сведения о форматировании см. в разделе Типы форматирования.For more information about formatting, see Formatting Types.
providerПараметр — это IFormatProvider реализация, GetFormat метод которой возвращает NumberFormatInfo объект.The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. Как правило, provider является CultureInfo объектом или NumberFormatInfo объектом.Typically, provider is a CultureInfo object or a NumberFormatInfo object. providerПараметр предоставляет сведения о языке и региональных параметрах, используемые при форматировании.The provider parameter supplies culture-specific information used in formatting. Если provider параметр имеет null значение, возвращаемые значения форматируются с использованием NumberFormatInfo объекта для текущего языка и региональных параметров.If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.
См. также раздел
Применяется к
ToString()
Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.Converts the numeric value of this instance to its equivalent string representation.
public:
override System::String ^ ToString();public override string ToString ();override this.ToString : unit -> stringPublic Overrides Function ToString () As StringВозвращаемое значение
Строковое представление значения этого экземпляра.The string representation of the value of this instance.
Примеры
В следующем примере используется метод по умолчанию Double.ToString() для отображения строкового представления количества Double значений.The following example uses the default Double.ToString() method to display the string representations of a number of Double values.
double number;
number = 1.6E20;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());
number = 1.6E2;
// Displays 160.
Console.WriteLine(number.ToString());
number = -3.541;
// Displays -3.541.
Console.WriteLine(number.ToString());
number = -1502345222199E-07;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());
number = -15023452221990199574E-09;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());
number = .60344;
// Displays 0.60344.
Console.WriteLine(number.ToString());
number = .000000001;
// Displays 1E-09.
Console.WriteLine(number.ToString());
Dim number As Double
number = 1.6E20
' Displays 1.6E+20.
Console.WriteLIne(number.ToString())
number = 1.6E2
' Displays 160.
Console.WriteLine(number.ToString())
number = -3.541
' Displays -3.541.
Console.WriteLine(number.ToString())
number = -1502345222199E-07
' Displays -150234.5222199.
Console.WriteLine(number.ToString())
number = -15023452221990199574E-09
' Displays -15023452221.9902.
Console.WriteLine(number.ToString())
number = .60344
' Displays 0.60344.
Console.WriteLine(number.ToString())
number = .000000001
' Displays 1E-09.
Console.WriteLine(number.ToString())
В следующем примере демонстрируется применение ToString.The following example illustrates the use of ToString.
bool done = false;
String^ inp;
do
{
Console::Write( "Enter a real number: " );
inp = Console::ReadLine();
try
{
d = Double::Parse( inp );
Console::WriteLine( "You entered {0}.", d );
done = true;
}
catch ( FormatException^ )
{
Console::WriteLine( "You did not enter a number." );
}
catch ( Exception^ e )
{
Console::WriteLine( "An exception occurred while parsing your response: {0}", e );
}
}
while ( !done );
bool done = false;
string inp;
do {
Console.Write("Enter a real number: ");
inp = Console.ReadLine();
try {
d = Double.Parse(inp);
Console.WriteLine("You entered {0}.", d.ToString());
done = true;
}
catch (FormatException) {
Console.WriteLine("You did not enter a number.");
}
catch (ArgumentNullException) {
Console.WriteLine("You did not supply any input.");
}
catch (OverflowException) {
Console.WriteLine("The value you entered, {0}, is out of range.", inp);
}
} while (!done);
Dim Done As Boolean = False
Dim Inp As String
Do
Console.Write("Enter a real number: ")
inp = Console.ReadLine()
Try
D = Double.Parse(inp)
Console.WriteLine("You entered " + D.ToString() + ".")
Done = True
Catch e As FormatException
Console.WriteLine("You did not enter a number.")
Catch e As ArgumentNullException
Console.WriteLine("You did not supply any input.")
Catch e As OverflowException
Console.WriteLine("The value you entered, {0}, is out of range.", inp)
End Try
Loop While Not Done
Комментарии
ToString()Метод форматирует Double значение в формате по умолчанию ("G" или "общий") текущего языка и региональных параметров.The ToString() method formats a Double value in the default ("G", or general) format of the current culture. Если необходимо указать другой формат, точность или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:If you want to specify a different format, precision, or culture, use the other overloads of the ToString method, as follows:
| Использование форматаTo use format | Для языка и региональных параметровFor culture | Использование перегрузкиUse the overload |
|---|---|---|
| Формат по умолчанию ("G")Default ("G") format | Конкретный язык и региональные параметрыA specific culture | ToString(IFormatProvider) |
| Конкретный формат или точностьA specific format or precision | Культура по умолчанию (текущий)Default (current) culture | ToString(String) |
| Конкретный формат или точностьA specific format or precision | Конкретный язык и региональные параметрыA specific culture | ToString(String, IFormatProvider) |
Возвращаемое значение может быть PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol или строкой вида:The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:
[знак] целочисленные цифры [. [ дробные цифры]] [E [знак] экспоненциальные цифры][sign]integral-digits[.[fractional-digits]][E[sign]exponential-digits]
Необязательные элементы заключены в квадратные скобки ([и]).Optional elements are framed in square brackets ([ and ]). Элементы, содержащие термин "цифры", состоят из ряда числовых символов в диапазоне от 0 до 9.Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. Поддерживаются элементы, перечисленные в следующей таблице.The elements listed in the following table are supported.
| ЭлементElement | ОписаниеDescription |
|---|---|
| signsign | Знак отрицательного или положительного знака.A negative sign or positive sign symbol. |
| целые числаintegral-digits | Последовательность цифр, указывающих целую часть числа.A series of digits specifying the integral part of the number. Целочисленные цифры могут отсутствовать, если есть дробные разряды.Integral-digits can be absent if there are fractional-digits. |
| '.''.' | Символ десятичной запятой, зависящий от языка и региональных параметров.A culture-specific decimal point symbol. |
| Дробные разрядыfractional-digits | Последовательность цифр, указывающая дробную часть числа.A series of digits specifying the fractional part of the number. |
| "E"'E' | Символ верхнего регистра "E", указывающий экспоненциальную (экспоненциальную) нотацию.An uppercase character 'E', indicating exponential (scientific) notation. |
| экспоненциальные цифрыexponential-digits | Последовательность цифр, указывающая показатель степени.A series of digits specifying an exponent. |
Примеры возвращаемых значений: "100", "-123 456 789", "123,45 E + 6", "500", "3,1416", "600", "-0,123" и "-Infinity".Some examples of the return value are "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", and "-Infinity".
.NET Framework обеспечивает обширную поддержку форматирования, которая подробно описана в следующих разделах форматирования:The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:
Дополнительные сведения о спецификаторах числовых форматов см. в разделе строки стандартных числовых форматов и строки настраиваемых числовых форматов.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Дополнительные сведения о форматировании см. в разделе Типы форматирования.For more information about formatting, see Formatting Types.