Double.ToString Double.ToString Double.ToString Double.ToString Method

このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);

public string ToString (string format, IFormatProvider provider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, provider As IFormatProvider) As String

パラメーター

戻り値

実装

例

次の例では、表示、Doubleのいくつかの異なるカルチャを使用して、サポートされている標準の数値書式指定子の値します。The following example displays a Double value using each of the supported standard numeric format specifiers for several different cultures.

using namespace System;
using namespace System::Globalization;

int main(array<System::String ^> ^args)
{
   double value = 16325.62901;
   String^ specifier;
   CultureInfo^ culture;

   // Use standard numeric format specifiers.
   specifier = "G";
   culture = CultureInfo::CreateSpecificCulture("eu-ES");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    16325,62901
   Console::WriteLine(value.ToString(specifier, CultureInfo::InvariantCulture));
   // Displays:    16325.62901

   specifier = "C";
   culture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    $16,325.63
   culture = CultureInfo::CreateSpecificCulture("en-GB");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    £16,325.63

   specifier = "E04";
   culture = CultureInfo::CreateSpecificCulture("sv-SE");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays: 1,6326E+004   
   culture = CultureInfo::CreateSpecificCulture("en-NZ");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    1.6326E+004   

   specifier = "F";
   culture = CultureInfo::CreateSpecificCulture("fr-FR");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    16325,63
   culture = CultureInfo::CreateSpecificCulture("en-CA");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    16325.63

   specifier = "N";
   culture = CultureInfo::CreateSpecificCulture("es-ES");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    16.325,63
   culture = CultureInfo::CreateSpecificCulture("fr-CA");
   Console::WriteLine(value.ToString(specifier, culture));
   // Displays:    16 325,63

   specifier = "P";
   culture = CultureInfo::InvariantCulture;
   Console::WriteLine((value/10000).ToString(specifier, culture));
   // Displays:    163.26 %
   culture = CultureInfo::CreateSpecificCulture("ar-EG");
   Console::WriteLine((value/10000).ToString(specifier, culture));
   // Displays:    163.256 %

   return 0;
}

double value = 16325.62901;
string specifier;
CultureInfo culture;

// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays:    16325.62901

specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    £16,325.63

specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ");
 Console.WriteLine(value.ToString(specifier, culture));
// Displays:    1.6326E+004   

specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325.63

specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16 325,63

specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.256 %

Dim value As Double = 16325.62901
Dim specifier As String
Dim culture As CultureInfo

' Use standard numeric format specifiers.
specifier = "G"
culture = CultureInfo.CreateSpecificCulture("eu-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture))
' Displays:    16325.62901

specifier = "C"
culture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    £16,325.63

specifier = "E04"
culture = CultureInfo.CreateSpecificCulture("sv-SE")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ")
 Console.WriteLine(value.ToString(specifier, culture))
' Displays:    1.6326E+004   

specifier = "F"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325.63

specifier = "N"
culture = CultureInfo.CreateSpecificCulture("es-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16 325,63

specifier = "P"
culture = CultureInfo.InvariantCulture
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG")
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.256 %

使用例を次に示しますToStringを受け入れて、StringとIFormatProviderパラメーターとして。The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.

public ref class Temperature: public IFormattable
{
   // IFormattable.ToString implementation.
public:
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         if ( format->Equals( "F" ) )
         {
            return String::Format( "{0}'F", this->Value.ToString() );
         }

         if ( format->Equals( "C" ) )
         {
            return String::Format( "{0}'C", this->Celsius.ToString() );
         }
      }

      return m_value.ToString( format, provider );
   }

protected:
   // The value holder
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }
      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }
      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

public class Temperature : IFormattable {
	// IFormattable.ToString implementation.
	public string ToString(string format, IFormatProvider provider) {
		if( format != null ) {
			if( format.Equals("F") ) {
				return String.Format("{0}'F", this.Value.ToString());
			}
			if( format.Equals("C") ) {
				return String.Format("{0}'C", this.Celsius.ToString());
			}
		}

		return m_value.ToString(format, provider);
	}

	// The value holder
	protected double m_value;

	public double Value {
		get {
			return m_value;
		}
		set {
			m_value = value;
		}
	}

	public double Celsius {
		get {
			return (m_value-32.0)/1.8;
		}
		set {
			m_value = 1.8*value+32.0;
		}
	}
}

Public Class Temperature
    Implements IFormattable

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

注釈

ToString(String, IFormatProvider)メソッド形式、Double指定のカルチャの指定した形式の値。The ToString(String, IFormatProvider) method formats a Double value in a specified format of a specified culture. 別の形式またはカルチャを指定する場合の他のオーバー ロードを使用して、ToStringメソッドは、次のようにします。If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:

形式を使用するにはTo use format	カルチャFor culture	オーバー ロードを使用します。Use the overload
既定 ("G") の形式Default ("G") format	(現在) の既定のカルチャDefault (current) culture	ToString()
既定 ("G") の形式Default ("G") format	特定のカルチャA specific culture	ToString(IFormatProvider)
特定の形式または有効桁数A specific format or precision	(現在) の既定のカルチャDefault (current) culture	ToString(String)

戻り値がPositiveInfinitySymbol、 NegativeInfinitySymbol、NaNSymbolで指定された数値の文字列形式またはformatします。The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.

format D および X 以外の任意の有効な標準の数値書式指定子およびカスタム数値書式指定子の任意の組み合わせをパラメーターとして使用することができます。The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. 場合formatはnullか、[全般] の数値書式指定子 ("G") 書式がこのインスタンスの戻り値、空の文字列。If format is null or an empty string, the return value for this instance is formatted with the general numeric format specifier ("G").

.NET Framework は、次の書式設定のトピックで詳しく説明されている広範な書式設定のサポートを提供します。The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:

• 数値書式指定子の詳細については、次を参照してください。 Standard Numeric Format Stringsとカスタム数値書式指定文字列します。For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

• 書式設定に関する詳細については、次を参照してください。型の書式設定します。For more information about formatting, see Formatting Types.

providerパラメーターは、IFormatProvider実装がGetFormatメソッドを返します。 をNumberFormatInfoオブジェクト。The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. 通常、providerは、CultureInfoオブジェクトまたはNumberFormatInfoオブジェクト。Typically, provider is a CultureInfo object or a NumberFormatInfo object. providerパラメーター書式設定で使用されるカルチャ固有の情報を提供します。The provider parameter supplies culture-specific information used in formatting. 場合providerはnullを使用して、戻り値の形式が、NumberFormatInfo現在のカルチャ オブジェクト。If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.

既定では、戻り値では、最大 17 桁が内部的に保持されて 15 桁の精度がのみ格納します。By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. このインスタンスの値がある 15 桁の数字より大きい場合ToString返しますPositiveInfinitySymbolまたはNegativeInfinitySymbol予想された数の代わりにします。If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. 高い精度を必要とする場合は、指定formatが常に返します、17 桁の有効桁数、または"R"、"G17"書式指定を返す 15 桁の数ができる場合、その有効桁数または桁数が 17 数を表現できる場合最大有効桁数で表されます。If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.

注意 (呼び出し元)

場合によっては、/platform:x64 スイッチまたは /platform:anycpu スイッチを使用してコンパイルして 64 ビット システムで実行すると、"R" 標準の数値書式指定文字列で書式設定される Double 値のラウンドトリップに失敗することがあります。In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. この問題を回避するには、"G17" 標準の数値書式指定文字列を使用して Double 値を書式設定することができます。To work around this problem, you can format Double values by using the "G17" standard numeric format string. 次の例では、ラウンドトリップに失敗する Double 値を持つ "R" 書式指定文字列を使用しています。元の値のラウンドトリップに成功する "G17" 書式指定文字列も使用しています。The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

[!code-csharpSystem.Double.ToString#5] [!code-vbSystem.Double.ToString#5][!code-csharpSystem.Double.ToString#5] [!code-vbSystem.Double.ToString#5]

こちらもご覧ください

Parse(String)Parse(String)Parse(String)Parse(String)

.NET での型の書式設定Formatting Types in .NET

標準の数値書式指定文字列Standard Numeric Format Strings

カスタム数値書式指定文字列Custom Numeric Format Strings

方法: 数値に先行するゼロを埋め込むHow to: Pad a Number with Leading Zeros

サンプル: .NET Framework 4 の書式設定ユーティリティSample: .NET Framework 4 Formatting Utility

指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation, using the specified format.

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

public string ToString (string format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

パラメーター

戻り値

例外

例

次の例では、数値の値を定義し、書式を通貨値として、"C"標準書式指定文字列を使用して、次の 3 つの小数点以下桁数に数値の値として"N"の標準の数値書式指定文字列を使用しています。The following example defines a numeric value and formats it as a currency value by using the "C" standard numeric format string and as a numeric value to three decimal places by using the "N" standard numeric format string. 結果文字列は EN-US カルチャの規則を使用して書式設定されます。The result strings are formatted by using the conventions of the en-US culture. 数値書式指定文字列の詳細については、次を参照してください。 Standard Numeric Format Stringsとカスタム数値書式指定文字列します。For more information on numeric format strings, see Standard Numeric Format Strings and Custom Numeric Format Strings.

using System;

public class Example
{
   public static void Main()
   {
      float number = 1764.3789m;
      
      // Format as a currency value.
      Console.WriteLine(number.ToString("C"));
      
      // Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"));
   }
}
// The example displays the following output:
//       $1,764.38
//       1,764.379

Module Example
   Public Sub Main()
      Dim number As Double = 1764.3789
      
      ' Format as a currency value.
      Console.WriteLine(number.ToString("C"))
      
      ' Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"))
   End Sub
End Module
' The example displays the following output:
'       $1,764.38
'       1,764.379

次の例では、いくつかが表示されますDouble3 つのカスタム数値書式指定文字列とサポートされている標準の数値書式指定子を使用して値します。The following example displays several Double values using the supported standard numeric format specifiers together with three custom numeric format strings. これらのカスタム書式指定文字列のいずれかを埋め込む方法を示しています、Singleゼロで始まる値。One of those custom format strings illustrates how to pad a Single value with leading zeros. さらに、"R"を除く各標準書式指定子と精度指定子を使用します。In addition, the example uses precision specifiers with each standard format specifier except for "R". 0 から 3 の精度指定子の範囲の値。The values of the precision specifiers range from 0 to 3. 数値の値を文字列に変換するには、EN-US カルチャの書式指定規則を使用します。To convert the numeric values to strings, the example uses the formatting conventions of the en-US culture.

using namespace System;

void main()
{
   array<Double>^ numbers= {1054.32179, -195489100.8377, 1.0437E21, 
                            -1.0573e-05};
   array<String^>^ specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                                  "R", "#,000.000", "0.###E-000",
                                  "000,000,000,000.00###" };
   for each (Double number in numbers)
   {  
      Console::WriteLine("Formatting of {0}:", number);
      for each (String^ specifier in specifiers) {
         Console::WriteLine("   {0,-22} {1}", 
                            specifier + ":", number.ToString(specifier));
         // Add precision specifiers from 0 to 3.
         if (specifier->Length == 1 & ! specifier->Equals("R")) {
            for (int precision = 0; precision <= 3; precision++) {
               String^ pSpecifier = String::Format("{0}{1}", specifier, precision);
               Console::WriteLine("   {0,-22} {1}", 
                                  pSpecifier + ":", number.ToString(pSpecifier));
            }    
            Console::WriteLine();
         }   
      }
      Console::WriteLine();
   }
}
// The example displays the following output:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//       
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//       
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//       
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//       
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//       
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//       
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//       
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//       
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//       
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//       
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//       
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//       
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

double[] numbers= {1054.32179, -195489100.8377, 1.0437E21, 
                   -1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };
foreach (double number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers) {
      Console.WriteLine("   {0,-22} {1}", 
                        specifier + ":", number.ToString(specifier));
      // Add precision specifiers from 0 to 3.
      if (specifier.Length == 1 & ! specifier.Equals("R")) {
         for (int precision = 0; precision <= 3; precision++) {
            string pSpecifier = String.Format("{0}{1}", specifier, precision);
            Console.WriteLine("   {0,-22} {1}", 
                              pSpecifier + ":", number.ToString(pSpecifier));
         }    
         Console.WriteLine();
      }   
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//       
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//       
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//       
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//       
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//       
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//       
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//       
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//       
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//       
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//       
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//       
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//       
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//       
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//       
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//       
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//       
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//       
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//       
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//       
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//       
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//       
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//       
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//       
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//       
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//       
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//       
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//       
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//       
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//       
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//       
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001 

Dim numbers() As Double = {1054.32179, -195489100.8377, 1.0437E21, _
                         -1.0573e-05}
Dim specifiers() As String = { "C", "E", "e", "F", "G", "N", "P", _
                               "R", "#,000.000", "0.###E-000", _
                               "000,000,000,000.00###" }
For Each number As Double In numbers
   Console.WriteLine("Formatting of {0}:", number)
   For Each specifier As String In specifiers
      Console.WriteLine("   {0,-22} {1}", 
                        specifier + ":", number.ToString(specifier))
      ' Add precision specifiers from 0 to 3.
      If specifier.Length = 1 And Not specifier.Equals("R") Then
         For precision As Integer = 0 To 3
            Dim pSpecifier As String = String.Format("{0}{1}", specifier, precision)
            Console.WriteLine("   {0,-22} {1}", 
                              pSpecifier + ":", number.ToString(pSpecifier))
         Next
         Console.WriteLine()      
      End If
   Next
   Console.WriteLine()
Next
' The example displays the following output:
'       Formatting of 1054.32179:
'          C:                     $1,054.32
'          C0:                    $1,054
'          C1:                    $1,054.3
'          C2:                    $1,054.32
'          C3:                    $1,054.322
'       
'          E:                     1.054322E+003
'          E0:                    1E+003
'          E1:                    1.1E+003
'          E2:                    1.05E+003
'          E3:                    1.054E+003
'       
'          e:                     1.054322e+003
'          e0:                    1e+003
'          e1:                    1.1e+003
'          e2:                    1.05e+003
'          e3:                    1.054e+003
'       
'          F:                     1054.32
'          F0:                    1054
'          F1:                    1054.3
'          F2:                    1054.32
'          F3:                    1054.322
'       
'          G:                     1054.32179
'          G0:                    1054.32179
'          G1:                    1E+03
'          G2:                    1.1E+03
'          G3:                    1.05E+03
'       
'          N:                     1,054.32
'          N0:                    1,054
'          N1:                    1,054.3
'          N2:                    1,054.32
'          N3:                    1,054.322
'       
'          P:                     105,432.18 %
'          P0:                    105,432 %
'          P1:                    105,432.2 %
'          P2:                    105,432.18 %
'          P3:                    105,432.179 %
'       
'          R:                     1054.32179
'          #,000.000:             1,054.322
'          0.###E-000:            1.054E003
'          000,000,000,000.00###: 000,000,001,054.32179
'       
'       Formatting of -195489100.8377:
'          C:                     ($195,489,100.84)
'          C0:                    ($195,489,101)
'          C1:                    ($195,489,100.8)
'          C2:                    ($195,489,100.84)
'          C3:                    ($195,489,100.838)
'       
'          E:                     -1.954891E+008
'          E0:                    -2E+008
'          E1:                    -2.0E+008
'          E2:                    -1.95E+008
'          E3:                    -1.955E+008
'       
'          e:                     -1.954891e+008
'          e0:                    -2e+008
'          e1:                    -2.0e+008
'          e2:                    -1.95e+008
'          e3:                    -1.955e+008
'       
'          F:                     -195489100.84
'          F0:                    -195489101
'          F1:                    -195489100.8
'          F2:                    -195489100.84
'          F3:                    -195489100.838
'       
'          G:                     -195489100.8377
'          G0:                    -195489100.8377
'          G1:                    -2E+08
'          G2:                    -2E+08
'          G3:                    -1.95E+08
'       
'          N:                     -195,489,100.84
'          N0:                    -195,489,101
'          N1:                    -195,489,100.8
'          N2:                    -195,489,100.84
'          N3:                    -195,489,100.838
'       
'          P:                     -19,548,910,083.77 %
'          P0:                    -19,548,910,084 %
'          P1:                    -19,548,910,083.8 %
'          P2:                    -19,548,910,083.77 %
'          P3:                    -19,548,910,083.770 %
'       
'          R:                     -195489100.8377
'          #,000.000:             -195,489,100.838
'          0.###E-000:            -1.955E008
'          000,000,000,000.00###: -000,195,489,100.8377
'       
'       Formatting of 1.0437E+21:
'          C:                     $1,043,700,000,000,000,000,000.00
'          C0:                    $1,043,700,000,000,000,000,000
'          C1:                    $1,043,700,000,000,000,000,000.0
'          C2:                    $1,043,700,000,000,000,000,000.00
'          C3:                    $1,043,700,000,000,000,000,000.000
'       
'          E:                     1.043700E+021
'          E0:                    1E+021
'          E1:                    1.0E+021
'          E2:                    1.04E+021
'          E3:                    1.044E+021
'       
'          e:                     1.043700e+021
'          e0:                    1e+021
'          e1:                    1.0e+021
'          e2:                    1.04e+021
'          e3:                    1.044e+021
'       
'          F:                     1043700000000000000000.00
'          F0:                    1043700000000000000000
'          F1:                    1043700000000000000000.0
'          F2:                    1043700000000000000000.00
'          F3:                    1043700000000000000000.000
'       
'          G:                     1.0437E+21
'          G0:                    1.0437E+21
'          G1:                    1E+21
'          G2:                    1E+21
'          G3:                    1.04E+21
'       
'          N:                     1,043,700,000,000,000,000,000.00
'          N0:                    1,043,700,000,000,000,000,000
'          N1:                    1,043,700,000,000,000,000,000.0
'          N2:                    1,043,700,000,000,000,000,000.00
'          N3:                    1,043,700,000,000,000,000,000.000
'       
'          P:                     104,370,000,000,000,000,000,000.00 %
'          P0:                    104,370,000,000,000,000,000,000 %
'          P1:                    104,370,000,000,000,000,000,000.0 %
'          P2:                    104,370,000,000,000,000,000,000.00 %
'          P3:                    104,370,000,000,000,000,000,000.000 %
'       
'          R:                     1.0437E+21
'          #,000.000:             1,043,700,000,000,000,000,000.000
'          0.###E-000:            1.044E021
'          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
'       
'       Formatting of -1.0573E-05:
'          C:                     $0.00
'          C0:                    $0
'          C1:                    $0.0
'          C2:                    $0.00
'          C3:                    $0.000
'       
'          E:                     -1.057300E-005
'          E0:                    -1E-005
'          E1:                    -1.1E-005
'          E2:                    -1.06E-005
'          E3:                    -1.057E-005
'       
'          e:                     -1.057300e-005
'          e0:                    -1e-005
'          e1:                    -1.1e-005
'          e2:                    -1.06e-005
'          e3:                    -1.057e-005
'       
'          F:                     0.00
'          F0:                    0
'          F1:                    0.0
'          F2:                    0.00
'          F3:                    0.000
'       
'          G:                     -1.0573E-05
'          G0:                    -1.0573E-05
'          G1:                    -1E-05
'          G2:                    -1.1E-05
'          G3:                    -1.06E-05
'       
'          N:                     0.00
'          N0:                    0
'          N1:                    0.0
'          N2:                    0.00
'          N3:                    0.000
'       
'          P:                     0.00 %
'          P0:                    0 %
'          P1:                    0.0 %
'          P2:                    0.00 %
'          P3:                    -0.001 %
'       
'          R:                     -1.0573E-05
'          #,000.000:             000.000
'          0.###E-000:            -1.057E-005
'          000,000,000,000.00###: -000,000,000,000.00001

注釈

ToString(String)メソッド形式、Double現在のカルチャの規則を使用して指定した形式の値。The ToString(String) method formats a Double value in a specified format by using the conventions of the current culture. 別の形式またはカルチャを指定する場合の他のオーバー ロードを使用して、ToStringメソッドは、次のようにします。If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:

形式を使用するにはTo use format	カルチャFor culture	オーバー ロードを使用します。Use the overload
既定 ("G") の形式Default ("G") format	(現在) の既定のカルチャDefault (current) culture	ToString()
既定 ("G") の形式Default ("G") format	特定のカルチャA specific culture	ToString(IFormatProvider)
特定の形式または有効桁数A specific format or precision	特定のカルチャA specific culture	ToString(String, IFormatProvider)

戻り値がPositiveInfinitySymbol、 NegativeInfinitySymbol、NaNSymbolで指定された数値の文字列形式またはformatします。The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.

format D および X 以外の任意の有効な標準の数値書式指定子およびカスタム数値書式指定子の任意の組み合わせをパラメーターとして使用することができます。The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. 場合formatはnullまたは戻り値、空の文字列が、一般的な数値書式指定子 ("G") でフォーマットされています。If format is null or an empty string, the return value is formatted with the general numeric format specifier ("G").

.NET Framework は、次の書式設定のトピックで詳しく説明されている広範な書式設定のサポートを提供します。The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:

• 数値書式指定子の詳細については、次を参照してください。 Standard Numeric Format Stringsとカスタム数値書式指定文字列します。For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

• 書式設定に関する詳細については、次を参照してください。型の書式設定します。For more information about formatting, see Formatting Types.

既定では、戻り値では、最大 17 桁が内部的に保持されて 15 桁の精度がのみ格納します。By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. このインスタンスの値がある 15 桁の数字より大きい場合ToString返しますPositiveInfinitySymbolまたはNegativeInfinitySymbol予想された数の代わりにします。If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. 高い精度を必要とする場合は、指定formatが常に返します、17 桁の有効桁数、または"R"、"G17"書式指定を返す 15 桁の数ができる場合、その有効桁数または桁数が 17 数を表現できる場合最大有効桁数で表されます。If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.

注意 (呼び出し元)

場合によっては、/platform:x64 スイッチまたは /platform:anycpu スイッチを使用してコンパイルして 64 ビット システムで実行すると、"R" 標準の数値書式指定文字列で書式設定される Double 値のラウンドトリップに失敗することがあります。In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. この問題を回避するには、"G17" 標準の数値書式指定文字列を使用して Double 値を書式設定することができます。To work around this problem, you can format Double values by using the "G17" standard numeric format string. 次の例では、ラウンドトリップに失敗する Double 値を持つ "R" 書式指定文字列を使用しています。元の値のラウンドトリップに成功する "G17" 書式指定文字列も使用しています。The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

[!code-csharpSystem.Double.ToString#6] [!code-vbSystem.Double.ToString#6][!code-csharpSystem.Double.ToString#6] [!code-vbSystem.Double.ToString#6]

こちらもご覧ください

Parse(String)Parse(String)Parse(String)Parse(String)

.NET での型の書式設定Formatting Types in .NET

標準の数値書式指定文字列Standard Numeric Format Strings

カスタム数値書式指定文字列Custom Numeric Format Strings

方法: 数値に先行するゼロを埋め込むHow to: Pad a Number with Leading Zeros

このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

public:
 virtual System::String ^ ToString(IFormatProvider ^ provider);

public string ToString (IFormatProvider provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

パラメーター

戻り値

実装

例

次の例は、2 つの文字列表現を表示します。Doubleを使用して値CultureInfoいくつかの異なるカルチャを表すオブジェクト。The following example displays the string representation of two Double values using CultureInfo objects that represent several different cultures.

double value;

value = -16325.62015;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));

value = 16034.125E21;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

Dim value As Double 

value = -16325.62015
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))

value = 16034.125E21
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
'       -16325.62015
'       -16325.62015
'       -16325,62015
'       1.6034125E+25
'       1.6034125E+25
'       1,6034125E+25

使用例を次に示しますToStringを受け入れて、StringとIFormatProviderパラメーターとして。The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.

public ref class Temperature: public IFormattable
{
   // IFormattable.ToString implementation.
public:
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         if ( format->Equals( "F" ) )
         {
            return String::Format( "{0}'F", this->Value.ToString() );
         }

         if ( format->Equals( "C" ) )
         {
            return String::Format( "{0}'C", this->Celsius.ToString() );
         }
      }

      return m_value.ToString( format, provider );
   }

protected:
   // The value holder
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }
      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }
      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

public class Temperature : IFormattable {
	// IFormattable.ToString implementation.
	public string ToString(string format, IFormatProvider provider) {
		if( format != null ) {
			if( format.Equals("F") ) {
				return String.Format("{0}'F", this.Value.ToString());
			}
			if( format.Equals("C") ) {
				return String.Format("{0}'C", this.Celsius.ToString());
			}
		}

		return m_value.ToString(format, provider);
	}

	// The value holder
	protected double m_value;

	public double Value {
		get {
			return m_value;
		}
		set {
			m_value = value;
		}
	}

	public double Celsius {
		get {
			return (m_value-32.0)/1.8;
		}
		set {
			m_value = 1.8*value+32.0;
		}
	}
}

Public Class Temperature
    Implements IFormattable

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

注釈

ToString(IFormatProvider)メソッド形式、Double指定されたカルチャの形式 ("G"または [全般]) の既定値します。The ToString(IFormatProvider) method formats a Double value in the default ("G", or general) format of a specified culture. 別の形式またはカルチャを指定する場合の他のオーバー ロードを使用して、ToStringメソッドは、次のようにします。If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:

形式を使用するにはTo use format	カルチャFor culture	オーバー ロードを使用します。Use the overload
既定 ("G") の形式Default ("G") format	既定の (現在)Default (current)	ToString()
特定の形式または有効桁数A specific format or precision	(現在) の既定のカルチャDefault (current) culture	ToString(String)
特定の形式または有効桁数A specific format or precision	特定のカルチャA specific culture	ToString(String, IFormatProvider)

戻り値がPositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol、または形式の文字列。The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:

整数の桁の [サインイン] [です [。小数部の桁] [e [記号] 指数の桁数][sign]integral-digits[.[fractional-digits]][e[sign]exponential-digits]

省略可能な要素は、角かっこで囲ま ([と])。Optional elements are framed in square brackets ([ and ]). 数字の 0 から 9 までの一連の"digits"という語を含む要素で構成されます。Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. 次の表に示す要素がサポートされています。The elements listed in the following table are supported.

要素Element	説明Description
signsign	負の符号または正の記号。A negative sign or positive sign symbol.
integral-digitsintegral-digits	一連の数字の数の整数部分を指定します。A series of digits specifying the integral part of the number. 整数の桁がないことがあります - 桁の小数部がある場合。Integral-digits can be absent if there are fractional-digits.
'.''.'	カルチャに固有の小数点記号。A culture-specific decimal point symbol.
fractional-digitsfractional-digits	一連の数値の小数部を指定することです。A series of digits specifying the fractional part of the number.
'e''e'	小文字"e"(指数) 表記の指数を示します。A lowercase character 'e', indicating exponential (scientific) notation.
exponential-digitsexponential-digits	一連の指数を指定することです。A series of digits specifying an exponent.

戻り値の例をいくつかは、「100」、「-123,456,789」、"123.45 e + 6"、「500」、「3.1416」、「600」、「-0.123」と"-Infinity"です。Some examples of the return value are "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123", and "-Infinity".

このインスタンスには、一般の数値書式指定子 ("G") が表示されます。This instance is formatted with the general numeric format specifier ("G").

.NET Framework は、次の書式設定のトピックで詳しく説明されている広範な書式設定のサポートを提供します。The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:

• 数値書式指定子の詳細については、次を参照してください。 Standard Numeric Format Stringsとカスタム数値書式指定文字列します。For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

• 書式設定に関する詳細については、次を参照してください。型の書式設定します。For more information about formatting, see Formatting Types.

providerパラメーターは、IFormatProvider実装がGetFormatメソッドを返します。 をNumberFormatInfoオブジェクト。The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. 通常、providerは、CultureInfoオブジェクトまたはNumberFormatInfoオブジェクト。Typically, provider is a CultureInfo object or a NumberFormatInfo object. providerパラメーター書式設定で使用されるカルチャ固有の情報を提供します。The provider parameter supplies culture-specific information used in formatting. 場合providerはnullを使用して、戻り値の形式が、NumberFormatInfo現在のカルチャ オブジェクト。If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.

こちらもご覧ください

Parse(String)Parse(String)Parse(String)Parse(String)

StringStringStringString

.NET での型の書式設定Formatting Types in .NET

このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation.

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

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

戻り値

例

次の例では、既定値を使用してDouble.ToString()の数の文字列形式を表示するメソッドをDouble値。The following example uses the default Double.ToString() method to display the string representations of a number of Double values.

double number;

number = 1.6E20;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());

number = 1.6E2;
// Displays 160.
Console.WriteLine(number.ToString());

number = -3.541;
// Displays -3.541.
Console.WriteLine(number.ToString());

number = -1502345222199E-07;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());

number = -15023452221990199574E-09;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());

number = .60344;
// Displays 0.60344.
Console.WriteLine(number.ToString());

number = .000000001;
// Displays 1E-09.
Console.WriteLine(number.ToString());

Dim number As Double

number = 1.6E20
' Displays 1.6E+20.      
Console.WriteLIne(number.ToString())

number = 1.6E2
' Displays 160.
Console.WriteLine(number.ToString())

number = -3.541
' Displays -3.541.
Console.WriteLine(number.ToString())

number = -1502345222199E-07
' Displays -150234.5222199.
Console.WriteLine(number.ToString())

number = -15023452221990199574E-09
' Displays -15023452221.9902.
Console.WriteLine(number.ToString())

number = .60344
' Displays 0.60344.
Console.WriteLine(number.ToString())

number = .000000001
' Displays 1E-09.
Console.WriteLine(number.ToString())

使用例を次に示しますToStringします。The following example illustrates the use of ToString.

bool done = false;
String^ inp;
do
{
   Console::Write( "Enter a real number: " );
   inp = Console::ReadLine();
   try
   {
      d = Double::Parse( inp );
      Console::WriteLine( "You entered {0}.", d );
      done = true;
   }
   catch ( FormatException^ ) 
   {
      Console::WriteLine( "You did not enter a number." );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "An exception occurred while parsing your response: {0}", e );
   }

}
while (  !done );

   bool done = false;
   string inp;
   do {
      Console.Write("Enter a real number: ");
      inp = Console.ReadLine();
      try {
         d = Double.Parse(inp);
         Console.WriteLine("You entered {0}.", d.ToString());
         done = true;
      } 
      catch (FormatException) {
         Console.WriteLine("You did not enter a number.");
      }
catch (ArgumentNullException) {
         Console.WriteLine("You did not supply any input.");
      }
      catch (OverflowException) {
          Console.WriteLine("The value you entered, {0}, is out of range.", inp);      
      }
   } while (!done);

Dim Done As Boolean = False
Dim Inp As String
Do

    Console.Write("Enter a real number: ")
    inp = Console.ReadLine()
    Try
        D = Double.Parse(inp)
        Console.WriteLine("You entered " + D.ToString() + ".")
        Done = True
    Catch e As FormatException
        Console.WriteLine("You did not enter a number.")
    Catch e As ArgumentNullException
       Console.WriteLine("You did not supply any input.")
    Catch e As OverflowException
       Console.WriteLine("The value you entered, {0}, is out of range.", inp)      
    End Try
Loop While Not Done

注釈

ToString()メソッド形式、Double現在のカルチャの形式 ("G"または [全般]) の既定値します。The ToString() method formats a Double value in the default ("G", or general) format of the current culture. 別の形式、有効桁数、またはカルチャを指定する場合の他のオーバー ロードを使用して、ToStringメソッドは、次のようにします。If you want to specify a different format, precision, or culture, use the other overloads of the ToString method, as follows:

形式を使用するにはTo use format	カルチャFor culture	オーバー ロードを使用します。Use the overload
既定 ("G") の形式Default ("G") format	特定のカルチャA specific culture	ToString(IFormatProvider)
特定の形式または有効桁数A specific format or precision	(現在) の既定のカルチャDefault (current) culture	ToString(String)
特定の形式または有効桁数A specific format or precision	特定のカルチャA specific culture	ToString(String, IFormatProvider)

戻り値がPositiveInfinitySymbol、 NegativeInfinitySymbol、 NaNSymbol、または形式の文字列。The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:

整数の桁の [サインイン] [です [。小数部の桁] [e [記号] 指数の桁数][sign]integral-digits[.[fractional-digits]][e[sign]exponential-digits]

省略可能な要素は、角かっこで囲ま ([と])。Optional elements are framed in square brackets ([ and ]). 数字の 0 から 9 までの一連の"digits"という語を含む要素で構成されます。Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. 次の表に示す要素がサポートされています。The elements listed in the following table are supported.

要素Element	説明Description
signsign	負の符号または正の記号。A negative sign or positive sign symbol.
integral-digitsintegral-digits	一連の数字の数の整数部分を指定します。A series of digits specifying the integral part of the number. 整数の桁がないことがあります - 桁の小数部がある場合。Integral-digits can be absent if there are fractional-digits.
'.''.'	カルチャに固有の小数点記号。A culture-specific decimal point symbol.
fractional-digitsfractional-digits	一連の数値の小数部を指定することです。A series of digits specifying the fractional part of the number.
'e''e'	小文字"e"(指数) 表記の指数を示します。A lowercase character 'e', indicating exponential (scientific) notation.
exponential-digitsexponential-digits	一連の指数を指定することです。A series of digits specifying an exponent.

戻り値の例をいくつかは、「100」、「-123,456,789」、"123.45 e + 6"、「500」、「3.1416」、「600」、「-0.123」と"-Infinity"です。Some examples of the return value are "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123", and "-Infinity".

.NET Framework は、次の書式設定のトピックで詳しく説明されている広範な書式設定のサポートを提供します。The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:

• 数値書式指定子の詳細については、次を参照してください。 Standard Numeric Format Stringsとカスタム数値書式指定文字列します。For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

• 書式設定に関する詳細については、次を参照してください。型の書式設定します。For more information about formatting, see Formatting Types.

こちらもご覧ください

Parse(String)Parse(String)Parse(String)Parse(String)

StringStringStringString

.NET での型の書式設定Formatting Types in .NET