閱讀英文

共用方式為

Double.ToString 方法

  • 參考

定義

命名空間:
System
組件:
System.Runtime.dll
組件:
mscorlib.dll
組件:
netstandard.dll

將這個執行個體的數值轉換為其相等字串表示。

多載

ToString()

將這個執行個體的數值轉換為其相等字串表示。
ToString(IFormatProvider)

使用指定的特定文化特性格式資訊，將這個執行個體的數值轉換成它的相等字串表示。
ToString(String)

使用指定格式，將這個執行個體的數值轉換成它的相等字串表示。
ToString(String, IFormatProvider)

使用指定的格式和特定文化特性格式資訊，將這個執行個體的數值轉換成它的相等字串表示。

ToString()

來源:
Double.cs
來源:
Double.cs
來源:
Double.cs

將這個執行個體的數值轉換為其相等字串表示。

public override string ToString ();

傳回

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());

下列範例示範如何使用 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.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);

備註

方法會將 ToString() 值格式化 Double 為預設 (“G”，或目前文化特性的一般) 格式。 如果您想要指定不同的格式、有效位數或文化特性，請使用 方法的其他多載 ToString ，如下所示：

使用格式 針對文化特性 使用多載
默認 (“G”) 格式 特定文化特性 ToString(IFormatProvider)
特定格式或精確度 默認 (目前) 文化特性 ToString(String)
特定格式或精確度 特定文化特性 ToString(String, IFormatProvider)

傳回值可以是 PositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol或格式的字串：

[sign]integral-digits[.[fractional-digits][E[sign]exponential-digits]

選擇性元素會以方括弧括住， ([ 和 ]) 。 包含「數位」一詞的專案包含一系列範圍從 0 到 9 的數位字元。 下表所列的專案受到支援。

項目 描述
簽署 負號或正負號符號。
整數數位 指定數位整數部分的一系列數位。 如果有小數位數，整數數位可能不存在。
'.' 特定文化特性的小數點符號。
fractional-digits 指定數位小數部分的一系列數位。
'E' 大寫字元 'E'，表示科學) 表示法的指數 (。
指數數位 指定指數的一系列數位。

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

.NET 提供廣泛的格式支援，如下列格式主題中更詳細地說明：

另請參閱

適用於

.NET 9 及其他版本
產品 版本
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(IFormatProvider)

來源:
Double.cs
來源:
Double.cs
來源:
Double.cs

使用指定的特定文化特性格式資訊，將這個執行個體的數值轉換成它的相等字串表示。

public string ToString (IFormatProvider provider);
public string ToString (IFormatProvider? provider);

參數

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

下列範例說明如何使用 ToString，並採用 String 和 IFormatProvider 作為參數。

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;
        }
    }
}

備註

方法會將 ToString(IFormatProvider) 值格式化 Double 為預設 (“G”，或指定文化特性的一般) 格式。 如果您要指定不同的格式或文化特性，請使用 方法的其他多載 ToString ，如下所示：

使用格式 針對文化特性 使用多載
默認 (“G”) 格式 默認 (目前) ToString()
特定格式或精確度 默認 (目前) 文化特性 ToString(String)
特定格式或精確度 特定文化特性 ToString(String, IFormatProvider)

傳回值可以是 PositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol或格式的字串：

[sign]integral-digits[.[fractional-digits][E[sign]exponential-digits]

選擇性元素會以方括弧括住， ([ 和 ]) 。 包含「數位」一詞的專案包含一系列範圍從 0 到 9 的數位字元。 下表所列的專案受到支援。

項目 描述
簽署 負號或正負號符號。
整數數位 指定數位整數部分的一系列數位。 如果有小數位數，整數數位可能不存在。
'.' 特定文化特性的小數點符號。
fractional-digits 指定數位小數部分的一系列數位。
'E' 大寫字元 'E'，表示科學) 表示法的指數 (。
指數數位 指定指數的一系列數位。

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

這個實例會使用一般數值格式規範來格式化 (“G”) 。

.NET 提供廣泛的格式支援，如下列格式主題中更詳細地說明：

參數provider是實IFormatProvider作，其方法會NumberFormatInfo傳GetFormat回 物件。 一般而言， provider 是 CultureInfo 對象或 NumberFormatInfo 物件。 參數 provider 會提供用於格式設定的文化特性特定資訊。 如果 為 providernull，則會使用 NumberFormatInfo 目前文化特性的物件來格式化傳回值。

另請參閱

適用於

.NET 9 及其他版本
產品 版本
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(String)

來源:
Double.cs
來源:
Double.cs
來源:
Double.cs

使用指定格式，將這個執行個體的數值轉換成它的相等字串表示。

public string ToString (string format);
public string ToString (string? format);

參數

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

下列範例使用支援的標準數值格式規範搭配三個自定義數值格式字元串，顯示數 Double 個值。 其中一個自定義格式字串說明如何使用前置零填補 Single 值。 此外，此範例使用精確度規範搭配每個標準格式規範，但 “R” 除外。 有效位數規範的值範圍從 0 到 3。 為了將數值轉換成字串，此範例會使用 en-US 文化特性的格式慣例。

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

備註

方法 ToString(String) 會使用目前文化特性的慣例，以指定格式格式化 Double 值。 如果您要指定不同的格式或文化特性，請使用 方法的其他多載 ToString ，如下所示：

使用格式 針對文化特性 使用多載
默認 (“G”) 格式 默認 (目前) 文化特性 ToString()
默認 (“G”) 格式 特定文化特性 ToString(IFormatProvider)
特定格式或精確度 特定文化特性 ToString(String, IFormatProvider)

傳回值可以是 PositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol或數位的字串表示，如 所 format指定。

參數 format 可以是 D 和 X 以外的任何有效標準數值格式規範，以及自定義數值格式規範的任何組合。 如果 為 formatnull 或空字串，則傳回值會使用一般數值格式規範來格式化， (“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

另請參閱

適用於

.NET 9 及其他版本
產品 版本
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

ToString(String, IFormatProvider)

來源:
Double.cs
來源:
Double.cs
來源:
Double.cs

使用指定的格式和特定文化特性格式資訊，將這個執行個體的數值轉換成它的相等字串表示。

public string ToString (string format, IFormatProvider provider);
public string ToString (string? format, IFormatProvider? provider);

參數

format
String

數值格式字串。

provider
IFormatProvider

物件，提供特定文化特性格式資訊。

傳回

String

這個執行個體值的字串表示，如同 format 和 provider 所指定。

實作

ToString(String, IFormatProvider)

範例

下列範例會針對數個不同的 Double 文化特性，使用每個支援的標準數值格式規範來顯示值。

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 %

下列範例說明如何使用 ToString，並採用 String 和 IFormatProvider 作為參數。

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;
        }
    }
}

備註

方法會 ToString(String, IFormatProvider) 以指定文化特性的指定格式格式化 Double 值。 如果您要指定不同的格式或文化特性，請使用 方法的其他多載 ToString ，如下所示：

使用格式 針對文化特性 使用多載
默認 (“G”) 格式 默認 (目前) 文化特性 ToString()
默認 (“G”) 格式 特定文化特性 ToString(IFormatProvider)
特定格式或精確度 默認 (目前) 文化特性 ToString(String)

傳回值可以是 PositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol或數位的字串表示，如 所 format指定。

參數 format 可以是 D 和 X 以外的任何有效標準數值格式規範，以及自定義數值格式規範的任何組合。 如果 為 formatnull 或空字串，則這個實例的傳回值會以一般數值格式規範格式化 (“G”) 。

.NET 提供廣泛的格式支援，如下列格式主題中更詳細地說明：

參數provider是實IFormatProvider作，其方法會NumberFormatInfo傳GetFormat回 物件。 一般而言， provider 是 CultureInfo 對象或 NumberFormatInfo 物件。 參數 provider 會提供用於格式設定的文化特性特定資訊。 如果 為 providernull，則會使用 NumberFormatInfo 目前文化特性的物件來格式化傳回值。

根據預設，傳回值只會包含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;
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
   }
}

另請參閱

適用於

.NET 9 及其他版本
產品 版本
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0