Поделиться через


Double.ToString Метод

Определение

Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.

Перегрузки

ToString()

Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.

ToString(IFormatProvider)

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

ToString(String)

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

ToString(String, IFormatProvider)

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

ToString()

Исходный код:
Double.cs
Исходный код:
Double.cs
Исходный код:
Double.cs

Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.

public:
 override System::String ^ ToString();
public override string ToString ();
override this.ToString : unit -> string
Public Overrides Function ToString () As String

Возвращаемое значение

Строковое представление значения этого экземпляра.

Примеры

В следующем примере используется метод по умолчанию Double.ToString() для отображения строковых представлений ряда значений Double .

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());
let number = 1.6E20
// Displays 1.6E+20.
printfn $"{number.ToString()}"

let number = 1.6E2
// Displays 160.
printfn $"{number.ToString()}"

let number = -3.541
// Displays -3.541.
printfn $"{number.ToString()}"

let number = -1502345222199E-07
// Displays -150234.5222199.
printfn $"{number.ToString()}"

let number = -15023452221990199574E-09
// Displays -15023452221.9902.
printfn $"{number.ToString()}"

let number = 0.60344
// Displays 0.60344.
printfn $"{number.ToString()}"

let number = 0.000000001
// Displays 1E-09.
printfn $"{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.

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);
let mutable completed = false
while not completed do
    printf "Enter a real number: "
    let inp = stdin.ReadLine()
    try
        let d = Double.Parse inp
        printfn $"You entered {d}."
        completed <- true
    with
    | :? FormatException ->
        printfn "You did not enter a number."
    | :? ArgumentNullException ->
        printfn "You did not supply any input."
    | :? OverflowException ->
         printfn $"The value you entered, {inp}, is out of range."
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" или "общий") текущего языка и региональных параметров. Если вы хотите указать другой формат, точность или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:

Использование формата Для языка и региональных параметров Использование перегрузки
Формат по умолчанию ("G") Определенный язык и региональные параметры ToString(IFormatProvider)
Определенный формат или точность Язык и региональные параметры по умолчанию (текущий) ToString(String)
Определенный формат или точность Определенный язык и региональные параметры ToString(String, IFormatProvider)

Возвращаемое значение может быть PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolили строкой в формате :

[sign]целочисленные цифры[.[ fractional-digits]][E[sign]exponential-digits]

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

Элемент Описание
sign Знак отрицательного или положительного знака.
целочисленные цифры Ряд цифр, указывающий неотъемлемую часть числа. Целочисленные цифры могут отсутствовать при наличии дробных разрядов.
'.' Символ десятичной запятой для конкретного языка и региональных параметров.
дробные цифры Ряд цифр, указывающий дробную часть числа.
"E" Символ верхнего регистра "E", указывающий экспоненциальную (экспоненциальную) нотацию.
экспоненциальные цифры Ряд цифр, указывающих степень.

Некоторые примеры возвращаемого значения: "100", "-123 456 789", "123,45E+6", "500", "3,1416", "600", "-0,123" и "-Infinity".

.NET предоставляет расширенную поддержку форматирования, которая более подробно описана в следующих разделах:

См. также раздел

Применяется к

ToString(IFormatProvider)

Исходный код:
Double.cs
Исходный код:
Double.cs
Исходный код:
Double.cs

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

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 -> string
Public Function ToString (provider As IFormatProvider) As String

Параметры

provider
IFormatProvider

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

Возвращаемое значение

Строковое представление значения данного экземпляра, определяемое параметром provider.

Реализации

Примеры

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

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
let value = -16325.62015
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE")}"""

let value = 16034.125E21
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{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 .

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;
        }
    }
}
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () =
            (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

    // IFormattable.ToString implementation.
    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)
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" или "общий") указанного языка и региональных параметров. Если вы хотите указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:

Использование формата Для языка и региональных параметров Использование перегрузки
Формат по умолчанию ("G") По умолчанию (текущий) ToString()
Определенный формат или точность Язык и региональные параметры по умолчанию (текущий) ToString(String)
Определенный формат или точность Определенный язык и региональные параметры ToString(String, IFormatProvider)

Возвращаемое значение может быть PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolили строкой в формате :

[sign]целочисленные цифры[.[ fractional-digits]][E[sign]exponential-digits]

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

Элемент Описание
sign Знак отрицательного или положительного знака.
целочисленные цифры Ряд цифр, указывающий неотъемлемую часть числа. Целочисленные цифры могут отсутствовать при наличии дробных разрядов.
'.' Символ десятичной запятой для конкретного языка и региональных параметров.
дробные цифры Ряд цифр, указывающий дробную часть числа.
"E" Символ верхнего регистра "E", указывающий экспоненциальную (экспоненциальную) нотацию.
экспоненциальные цифры Ряд цифр, указывающих степень.

Некоторые примеры возвращаемого значения: "100", "-123 456 789", "123,45E+6", "500", "3,1416", "600", "-0,123" и "-Infinity".

Этот экземпляр отформатирован с помощью описателя общего числового формата ("G").

.NET предоставляет расширенную поддержку форматирования, которая более подробно описана в следующих разделах:

Параметр provider является реализацией, IFormatProvider метод которой GetFormat возвращает NumberFormatInfo объект . Как правило, provider является CultureInfo объектом или NumberFormatInfo объектом . Параметр provider предоставляет сведения, относящиеся к языку и региональным параметрам, которые используются при форматировании. Если provider имеет значение null, возвращаемое значение форматируется с использованием NumberFormatInfo объекта для текущего языка и региональных параметров.

См. также раздел

Применяется к

ToString(String)

Исходный код:
Double.cs
Исходный код:
Double.cs
Исходный код:
Double.cs

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

public:
 System::String ^ ToString(System::String ^ format);
public string ToString (string format);
public string ToString (string? format);
override this.ToString : string -> string
Public Function ToString (format As String) As String

Параметры

format
String

Строка числового формата.

Возвращаемое значение

Строковое представление значения данного экземпляра, определяемое параметром format.

Исключения

format недопустим.

Примеры

В следующем примере определяется числовое значение и форматирует его как денежное значение с помощью строки стандартного числового формата "C", а как числовое значение до трех десятичных разрядов с помощью строки стандартного числового формата "N". Результирующих строк форматируется с использованием соглашений языка и региональных параметров en-US. Дополнительные сведения о строках числового формата см. в разделах Строки стандартного числового формата и Строки настраиваемого числового формата.

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
open System

let number = 1764.3789m

// Format as a currency value.
printfn $"""{number.ToString "C"}"""

// Format as a numeric value with 3 decimal places.
printfn $"""{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 значений с использованием поддерживаемых описателей стандартного числового формата вместе с тремя строками настраиваемого числового формата. Одна из этих строк настраиваемого формата показывает, как заполнить Single значение нулем в начале. Кроме того, в примере используются описатели точности с каждым описателем стандартного формата, кроме "R". Значения описателей точности варьируются от 0 до 3. Для преобразования числовых значений в строки в примере используются соглашения о форматировании языка и региональных параметров en-US.

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
let numbers =
    [| 1054.32179; -195489100.8377; 1.0437E21; -1.0573e-05 |]
let specifiers =
    [| "C"; "E"; "e"; "F"; "G"; "N"; "P"
       "R"; "#,000.000"; "0.###E-000"
       "000,000,000,000.00###" |]
for number in numbers do
    printfn $"Formatting of {number}:"
    for specifier in specifiers do
        printfn $"""   {specifier + ":",-22} {number.ToString specifier}"""
        // Add precision specifiers from 0 to 3.
        if specifier.Length = 1 && not (specifier.Equals "R") then
            for precision = 0 to 3 do
                let pSpecifier = $"{specifier}{precision}"
                printfn $"""   {pSpecifier + ":",-22} {number.ToString pSpecifier}"""
            printfn ""
    printfn ""
// 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 значение в указанном формате, используя соглашения текущего языка и региональных параметров. Если вы хотите указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:

Использование формата Для языка и региональных параметров Использование перегрузки
Формат по умолчанию ("G") Язык и региональные параметры по умолчанию (текущий) ToString()
Формат по умолчанию ("G") Определенный язык и региональные параметры ToString(IFormatProvider)
Определенный формат или точность Определенный язык и региональные параметры ToString(String, IFormatProvider)

Возвращаемое значение может быть PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolили строковое представление числа, как указано в format.

Параметр format может быть любым допустимым описателем стандартного числового формата, за исключением D и X, а также любым сочетанием описателей настраиваемого числового формата. Если format имеет значение null или является пустой строкой, возвращаемое значение форматируется с помощью описателя общего числового формата ("G").

.NET предоставляет расширенную поддержку форматирования, которая более подробно описана в следующих разделах:

По умолчанию возвращаемое значение содержит только 15 цифр точности, хотя максимум 17 цифр поддерживается внутри. Если значение этого экземпляра превышает 15 цифр, ToString возвращает PositiveInfinitySymbol значение или NegativeInfinitySymbol вместо ожидаемого числа. Если требуется больше точности, укажите format с помощью спецификации формата "G17", которая всегда возвращает 17 цифр точности, или "R", которая возвращает 15 цифр, если число может быть представлено с этой точностью, или 17 цифр, если число может быть представлено только с максимальной точностью.

Примечания для тех, кто вызывает этот метод

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

using System;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Attempting to round-trip a Double with 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R");
      double roundTripped = double.Parse(valueString);
      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");
      double roundTripped17 = double.Parse(valueString17);
      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
open System

printfn "Attempting to round-trip a Double with 'R':"
let initialValue = 0.6822871999174
let valueString = initialValue.ToString "R"
let roundTripped = Double.Parse valueString
printfn $"{initialValue:R} = {roundTripped:R}: {initialValue.Equals roundTripped}\n"

printfn "Attempting to round-trip a Double with 'G17':"
let valueString17 = initialValue.ToString "G17"
let roundTripped17 = Double.Parse valueString17
printfn $"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals roundTripped17}\n"
// 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
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")
      Dim roundTripped As Double = Double.Parse(valueString)
      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")
      Dim roundTripped17 As Double = Double.Parse(valueString17)
      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

См. также раздел

Применяется к

ToString(String, IFormatProvider)

Исходный код:
Double.cs
Исходный код:
Double.cs
Исходный код:
Double.cs

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

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 -> string
Public Function ToString (format As String, provider As IFormatProvider) As String

Параметры

format
String

Строка числового формата.

provider
IFormatProvider

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

Возвращаемое значение

Строковое представление значения данного экземпляра, определяемое параметрами format и provider.

Реализации

Примеры

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

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 %
let value = 16325.62901

// Use standard numeric format specifiers.
let specifier = "G"
let culture = CultureInfo.CreateSpecificCulture "eu-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,62901
printfn $"{value.ToString(specifier, CultureInfo.InvariantCulture)}"
// Displays:    16325.62901

let specifier = "C"
let culture = CultureInfo.CreateSpecificCulture "en-US"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    $16,325.63
let culture = CultureInfo.CreateSpecificCulture "en-GB"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    £16,325.63

let specifier = "E04"
let culture = CultureInfo.CreateSpecificCulture "sv-SE"
printfn $"{value.ToString(specifier, culture)}"
// Displays: 1,6326E+004
let culture = CultureInfo.CreateSpecificCulture "en-NZ"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    1.6326E+004

let specifier = "F"
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,63
let culture = CultureInfo.CreateSpecificCulture "en-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325.63

let specifier = "N"
let culture = CultureInfo.CreateSpecificCulture "es-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16.325,63
let culture = CultureInfo.CreateSpecificCulture "fr-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16 325,63

let specifier = "P"
let culture = CultureInfo.InvariantCulture
printfn $"{(value / 10000.).ToString(specifier, culture)}"
// Displays:    163.26 %
let culture = CultureInfo.CreateSpecificCulture "ar-EG"
printfn $"{(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 .

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;
        }
    }
}
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () =
            (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

    // IFormattable.ToString implementation.
    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)
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 значение в указанном формате указанного языка и региональных параметров. Если вы хотите указать другой формат или язык и региональные параметры, используйте другие перегрузки ToString метода следующим образом:

Использование формата Для языка и региональных параметров Использование перегрузки
Формат по умолчанию ("G") Язык и региональные параметры по умолчанию (текущий) ToString()
Формат по умолчанию ("G") Определенный язык и региональные параметры ToString(IFormatProvider)
Определенный формат или точность Язык и региональные параметры по умолчанию (текущий) ToString(String)

Возвращаемое значение может быть PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolили строковое представление числа, как указано в format.

Параметр format может быть любым допустимым описателем стандартного числового формата, за исключением D и X, а также любым сочетанием описателей настраиваемого числового формата. Если format имеет значение null или является пустой строкой, возвращаемое значение для этого экземпляра форматируется с помощью описателя общего числового формата ("G").

.NET предоставляет расширенную поддержку форматирования, которая более подробно описана в следующих разделах:

Параметр provider является реализацией, IFormatProvider метод которой GetFormat возвращает NumberFormatInfo объект . Как правило, provider является CultureInfo объектом или NumberFormatInfo объектом . Параметр provider предоставляет сведения, относящиеся к языку и региональным параметрам, которые используются при форматировании. Если provider имеет значение null, возвращаемое значение форматируется с использованием NumberFormatInfo объекта для текущего языка и региональных параметров.

По умолчанию возвращаемое значение содержит только 15 цифр точности, хотя максимум 17 цифр поддерживается внутри. Если значение этого экземпляра превышает 15 цифр, ToString возвращает PositiveInfinitySymbol значение или NegativeInfinitySymbol вместо ожидаемого числа. Если требуется больше точности, укажите format с помощью спецификации формата "G17", которая всегда возвращает 17 цифр точности, или "R", которая возвращает 15 цифр, если число может быть представлено с этой точностью, или 17 цифр, если число может быть представлено только с максимальной точностью.

Примечания для тех, кто вызывает этот метод

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

using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      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
   }
}
open System
open System.Globalization

printfn "Attempting to round-trip a Double with 'R':"
let initialValue = 0.6822871999174
let valueString = initialValue.ToString("R", CultureInfo.InvariantCulture)
let roundTripped = Double.Parse(valueString, CultureInfo.InvariantCulture)
printfn $"{initialValue:R} = {roundTripped:R}: {initialValue.Equals roundTripped}\n"

printfn "Attempting to round-trip a Double with 'G17':"
let valueString17 = initialValue.ToString("G17", CultureInfo.InvariantCulture)
let roundTripped17 = Double.Parse(valueString17, CultureInfo.InvariantCulture)
printfn $"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals roundTripped17}\n"
// 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

См. также раздел

Применяется к