Double.ToString 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将此实例的数值转换为其等效的字符串表示形式。

重载

ToString()	将此实例的数值转换为其等效的字符串表示形式。
ToString(IFormatProvider)	使用指定的区域性特定格式信息，将此实例的数值转换为它的等效字符串表示形式。
ToString(String)	使用指定的格式，将此实例的数值转换为它的等效字符串表示形式。
ToString(String, IFormatProvider)	使用指定的格式和区域性特定格式信息，将此实例的数值转换为它的等效字符串表示形式。

ToString()

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

将此实例的数值转换为其等效的字符串表示形式。

public:
 override System::String ^ ToString();

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

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]integral-digits[.[fractional-digits]][E[sign]exponential-digits]

可选元素以方括号 ([ 和 ]) 。包含术语“digits”的元素由一系列介于 0 到 9 的数字字符组成。支持下表中列出的元素。

元素	说明
sign	负号或正符号。
integral-digits	一系列数字，指定数字的整型部分。如果有小数位数，则整型数字可能不存在。
'.'	区域性特定的小数点符号。
fractional-digits	一系列数字，指定数字的小数部分。
“E”	一个大写字符“E”，表示指数 (科学) 表示法。
exponential-digits	一系列指定指数的数字。

返回值的一些示例包括“100”、“-123,456,789”、“123.45E+6”、“500”、“3.1416”、“600”、“-0.123”和“-Infinity”。

.NET 提供广泛的格式设置支持，以下格式设置主题对此进行了更详细的介绍：

有关数值格式说明符的详细信息，请参阅标准数值格式字符串和自定义数值格式字符串。
有关格式设置的详细信息，请参阅格式设置类型。

另请参阅

适用于

ToString(IFormatProvider)

Source:: Double.cs

Source:: Double.cs

Source:: 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

一个提供区域性特定的格式设置信息的对象。

String

此实例的值的字符串表示形式，由 provider 指定。

实现

ToString(IFormatProvider)

示例

以下示例使用CultureInfo表示多个不同区域性的对象显示两Double个值的字符串表示形式。

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]integral-digits[.[fractional-digits]][E[sign]exponential-digits]

可选元素以方括号 ([ 和 ]) 。包含术语“digits”的元素由一系列介于 0 到 9 的数字字符组成。支持下表中列出的元素。

元素	说明
sign	负号或正符号。
integral-digits	一系列数字，指定数字的整型部分。如果有小数位数，则整型数字可能不存在。
'.'	区域性特定的小数点符号。
fractional-digits	一系列数字，指定数字的小数部分。
“E”	一个大写字符“E”，表示指数 (科学) 表示法。
exponential-digits	一系列指定指数的数字。

返回值的一些示例包括“100”、“-123,456,789”、“123.45E+6”、“500”、“3.1416”、“600”、“-0.123”和“-Infinity”。

此实例使用常规数值格式说明符 (“G”) 进行格式化。

.NET 提供广泛的格式设置支持，以下格式设置主题对此进行了更详细的介绍：

有关数值格式说明符的详细信息，请参阅标准数值格式字符串和自定义数值格式字符串。
有关格式设置的详细信息，请参阅格式设置类型。

provider参数是其IFormatProvider方法返回 NumberFormatInfo 对象的实现GetFormat。通常， provider 是对象 CultureInfo 或 NumberFormatInfo 对象。参数 provider 提供格式设置中使用的特定于区域性的信息。如果 provider 为 null，则使用 NumberFormatInfo 当前区域性的对象设置返回值的格式。

另请参阅

适用于

ToString(String)

Source:: Double.cs

Source:: Double.cs

Source:: 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

一个数值格式字符串。

String

此实例的值的字符串表示形式，由 format 指定。

例外

FormatException

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 ，而不是预期的数字。如果需要更高的精度，请使用“G17”格式规范（ format 始终返回 17 位精度）或“R”指定，如果可以使用该精度表示数字，则返回 15 位数字;如果只能以最大精度表示数字，则返回 17 位数字。

调用方说明

在某些情况下，如果使用“R”标准数字格式字符串格式化的 Double 值使用 /platform:x64 或 /platform:anycpu 开关编译并在 64 位系统上运行，则该值将无法成功往返。若要解决此问题，可以使用“G17”标准数字格式字符串格式化 Double 值。以下示例将“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)

Source:: Double.cs

Source:: Double.cs

Source:: 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

一个提供区域性特定的格式设置信息的对象。

String

此实例的值的字符串表示形式，由 format 和 provider 指定。

实现

ToString(String, IFormatProvider)

示例

以下示例使用多个不同区域性的每个受支持的标准数字格式说明符显示一个 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方法返回 NumberFormatInfo 对象的实现GetFormat。通常， provider 是对象 CultureInfo 或 NumberFormatInfo 对象。参数 provider 提供格式设置中使用的特定于区域性的信息。如果 provider 为 null，则使用 NumberFormatInfo 当前区域性的对象设置返回值的格式。

调用方说明

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

另请参阅

适用于

通过

Double.ToString 方法

定义

重载

ToString()

返回

示例

注解

另请参阅

适用于

ToString(IFormatProvider)

参数

返回

实现

示例

注解

另请参阅

适用于

ToString(String)

参数

返回

例外

示例

注解

调用方说明

另请参阅

适用于

ToString(String, IFormatProvider)

参数

返回

实现

示例

注解

调用方说明

另请参阅

适用于

其他资源