Double.ToString Metode
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Mengonversi nilai numerik instans ini ke representasi string yang setara.
| ToString() |
Mengonversi nilai numerik instans ini ke representasi string yang setara. |
| ToString(IFormatProvider) |
Mengonversi nilai numerik instans ini ke representasi string yang setara menggunakan informasi format khusus budaya yang ditentukan. |
| ToString(String) |
Mengonversi nilai numerik instans ini ke representasi string yang setara, menggunakan format yang ditentukan. |
| ToString(String, IFormatProvider) |
Mengonversi nilai numerik instans ini ke representasi string yang setara menggunakan format yang ditentukan dan informasi format khusus budaya. |
- Sumber:
- Double.cs
- Sumber:
- Double.cs
- Sumber:
- Double.cs
Mengonversi nilai numerik instans ini ke representasi string yang setara.
public:
override System::String ^ ToString();public override string ToString ();override this.ToString : unit -> stringPublic Overrides Function ToString () As StringMengembalikan
Representasi string dari nilai instans ini.
Contoh
Contoh berikut menggunakan metode default Double.ToString() untuk menampilkan representasi string dari sejumlah Double nilai.
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())
Contoh berikut mengilustrasikan penggunaan 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
Keterangan
Metode memformat ToString()Double nilai dalam format default ("G", atau umum) dari budaya saat ini. Jika Anda ingin menentukan format, presisi, atau budaya yang berbeda, gunakan kelebihan ToString metode lainnya, sebagai berikut:
| Untuk menggunakan format | Untuk budaya | Menggunakan kelebihan beban |
|---|---|---|
| Format default ("G") | Budaya tertentu | ToString(IFormatProvider) |
| Format atau presisi tertentu | Kultur default (saat ini) | ToString(String) |
| Format atau presisi tertentu | Budaya tertentu | ToString(String, IFormatProvider) |
Nilai yang dikembalikan dapat berupa PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, atau string formulir:
[sign]integral-digits[.[ fractional-digits]][E[sign]exponential-digits]
Elemen opsional dibingkai dalam tanda kurung siku ([ dan ]). Elemen yang berisi istilah "digit" terdiri dari serangkaian karakter numerik mulai dari 0 hingga 9. Elemen yang tercantum dalam tabel berikut ini didukung.
| Elemen | Deskripsi |
|---|---|
| sign | Tanda negatif atau simbol tanda positif. |
| integral-digits | Serangkaian digit yang menentukan bagian integral dari angka tersebut. Digit integral dapat tidak ada jika ada digit pecahan. |
| '.' | Simbol titik desimal khusus budaya. |
| fractional-digits | Serangkaian digit yang menentukan bagian pecahan dari angka. |
| 'E' | Karakter huruf besar 'E', menunjukkan notasi eksponensial (ilmiah). |
| digit eksponensial | Serangkaian digit yang menentukan eksponen. |
Beberapa contoh nilai pengembalian adalah "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", dan "-Infinity".
.NET menyediakan dukungan pemformatan ekstensif, yang dijelaskan secara lebih rinci dalam topik pemformatan berikut:
Untuk informasi selengkapnya tentang penentu format numerik, lihat String Format Numerik Standar dan String Format Numerik Kustom.
Untuk informasi selengkapnya tentang pemformatan, lihat Tipe Pemformatan.
Lihat juga
Berlaku untuk
.NET 9 dan versi lainnya
| Produk | Versi |
|---|---|
| .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 |
- Sumber:
- Double.cs
- Sumber:
- Double.cs
- Sumber:
- Double.cs
Mengonversi nilai numerik instans ini ke representasi string yang setara menggunakan informasi format khusus budaya yang ditentukan.
public:
virtual System::String ^ ToString(IFormatProvider ^ provider);public:
System::String ^ ToString(IFormatProvider ^ provider);public string ToString (IFormatProvider provider);public string ToString (IFormatProvider? provider);override this.ToString : IFormatProvider -> stringPublic Function ToString (provider As IFormatProvider) As StringParameter
- provider
- IFormatProvider
Objek yang memasok informasi pemformatan khusus budaya.
Mengembalikan
Representasi string dari nilai instans ini seperti yang ditentukan oleh provider.
Penerapan
Contoh
Contoh berikut menampilkan representasi string dari dua Double nilai menggunakan CultureInfo objek yang mewakili beberapa budaya yang berbeda.
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
Contoh berikut mengilustrasikan penggunaan ToString, mengambil String dan IFormatProvider sebagai parameter.
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
Keterangan
Metode memformat ToString(IFormatProvider)Double nilai dalam format default ("G", atau umum) dari budaya tertentu. Jika Anda ingin menentukan format atau budaya yang berbeda, gunakan kelebihan beban ToString metode lainnya, sebagai berikut:
| Untuk menggunakan format | Untuk budaya | Menggunakan kelebihan beban |
|---|---|---|
| Format default ("G") | Default (saat ini) | ToString() |
| Format atau presisi tertentu | Kultur default (saat ini) | ToString(String) |
| Format atau presisi tertentu | Budaya tertentu | ToString(String, IFormatProvider) |
Nilai yang dikembalikan dapat berupa PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, atau string formulir:
[sign]integral-digits[.[ fractional-digits]][E[sign]exponential-digits]
Elemen opsional dibingkai dalam tanda kurung siku ([ dan ]). Elemen yang berisi istilah "digit" terdiri dari serangkaian karakter numerik mulai dari 0 hingga 9. Elemen yang tercantum dalam tabel berikut ini didukung.
| Elemen | Deskripsi |
|---|---|
| sign | Tanda negatif atau simbol tanda positif. |
| integral-digits | Serangkaian digit yang menentukan bagian integral dari angka tersebut. Digit integral dapat tidak ada jika ada digit pecahan. |
| '.' | Simbol titik desimal khusus budaya. |
| fractional-digits | Serangkaian digit yang menentukan bagian pecahan dari angka. |
| 'E' | Karakter huruf besar 'E', menunjukkan notasi eksponensial (ilmiah). |
| digit eksponensial | Serangkaian digit yang menentukan eksponen. |
Beberapa contoh nilai pengembalian adalah "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", dan "-Infinity".
Instans ini diformat dengan penentu format numerik umum ("G").
.NET menyediakan dukungan pemformatan ekstensif, yang dijelaskan secara lebih rinci dalam topik pemformatan berikut:
Untuk informasi selengkapnya tentang penentu format numerik, lihat String Format Numerik Standar dan String Format Numerik Kustom.
Untuk informasi selengkapnya tentang pemformatan, lihat Tipe Pemformatan.
Parameter provider adalah IFormatProvider implementasi yang metodenya GetFormat mengembalikan NumberFormatInfo objek. Biasanya, provider adalah CultureInfo objek atau NumberFormatInfo objek. Parameter memasok provider informasi khusus budaya yang digunakan dalam pemformatan. Jika provider adalah null, nilai pengembalian diformat menggunakan NumberFormatInfo objek untuk budaya saat ini.
Lihat juga
Berlaku untuk
.NET 9 dan versi lainnya
| Produk | Versi |
|---|---|
| .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 |
- Sumber:
- Double.cs
- Sumber:
- Double.cs
- Sumber:
- Double.cs
Mengonversi nilai numerik instans ini ke representasi string yang setara, menggunakan format yang ditentukan.
public:
System::String ^ ToString(System::String ^ format);public string ToString (string format);public string ToString (string? format);override this.ToString : string -> stringPublic Function ToString (format As String) As StringParameter
- format
- String
String format numerik.
Mengembalikan
Representasi string dari nilai instans ini seperti yang ditentukan oleh format.
Pengecualian
format tidak valid.
Contoh
Contoh berikut mendefinisikan nilai numerik dan memformatnya sebagai nilai mata uang dengan menggunakan string format numerik standar "C" dan sebagai nilai numerik ke tiga tempat desimal dengan menggunakan string format numerik standar "N". String hasil diformat dengan menggunakan konvensi budaya en-US. Untuk informasi selengkapnya tentang string format numerik, lihat String Format Numerik Standar dan String Format Numerik Kustom.
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
Contoh berikut menampilkan beberapa Double nilai menggunakan penentu format numerik standar yang didukung bersama dengan tiga string format numerik kustom. Salah satu string format kustom tersebut menggambarkan cara Single mengayuh nilai dengan nol di depannya. Selain itu, contoh menggunakan penentu presisi dengan setiap penentu format standar kecuali untuk "R". Nilai penentu presisi berkisar antara 0 hingga 3. Untuk mengonversi nilai numerik menjadi string, contohnya menggunakan konvensi pemformatan budaya 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
Keterangan
Metode memformat ToString(String)Double nilai dalam format tertentu dengan menggunakan konvensi budaya saat ini. Jika Anda ingin menentukan format atau budaya yang berbeda, gunakan kelebihan beban ToString metode lainnya, sebagai berikut:
| Untuk menggunakan format | Untuk budaya | Menggunakan kelebihan beban |
|---|---|---|
| Format default ("G") | Kultur default (saat ini) | ToString() |
| Format default ("G") | Budaya tertentu | ToString(IFormatProvider) |
| Format atau presisi tertentu | Budaya tertentu | ToString(String, IFormatProvider) |
Nilai yang dikembalikan dapat berupa PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, atau representasi string dari angka, seperti yang ditentukan oleh format.
Parameter format dapat berupa penentu format numerik standar yang valid kecuali untuk D dan X, serta kombinasi penentu format numerik kustom. Jika format adalah null atau string kosong, nilai yang dikembalikan diformat dengan penentu format numerik umum ("G").
.NET menyediakan dukungan pemformatan ekstensif, yang dijelaskan secara lebih rinci dalam topik pemformatan berikut:
Untuk informasi selengkapnya tentang penentu format numerik, lihat String Format Numerik Standar dan String Format Numerik Kustom.
Untuk informasi selengkapnya tentang pemformatan, lihat Jenis Pemformatan.
Secara default, nilai pengembalian hanya berisi 15 digit presisi meskipun maksimum 17 digit dipertahankan secara internal. Jika nilai instans ini memiliki lebih besar dari 15 digit, ToString mengembalikan atau NegativeInfinitySymbol alih-alih PositiveInfinitySymbol angka yang diharapkan. Jika Anda memerlukan lebih banyak presisi, tentukan format dengan spesifikasi format "G17", yang selalu mengembalikan 17 digit presisi, atau "R", yang mengembalikan 15 digit jika angka dapat diwakili dengan presisi tersebut atau 17 digit jika angka hanya dapat diwakili dengan presisi maksimum.
Catatan Bagi Pemanggil
Dalam beberapa kasus, nilai Double yang diformat dengan string format numerik standar "R" tidak berhasil melakukan format dua arah jika dikompilasi menggunakan /platform:x64 atau /platform:anycpu beralih dan berjalan pada sistem 64-bit. Untuk mengatasi masalah ini, Anda dapat memformat Double nilai dengan menggunakan string format numerik standar "G17". Contoh berikut menggunakan string format "R" dengan Double nilai yang tidak berhasil melakukan round-trip, dan juga menggunakan string format "G17" untuk berhasil melakukan round-trip nilai asli.
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
Lihat juga
- Parse(String)
- Tipe Pemformatan di .NET
- String Format Numerik Standar
- String Format Numerik Kustom
- Cara: Mem-Padding Angka dengan Awalan Nol
Berlaku untuk
.NET 9 dan versi lainnya
| Produk | Versi |
|---|---|
| .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 |
- Sumber:
- Double.cs
- Sumber:
- Double.cs
- Sumber:
- Double.cs
Mengonversi nilai numerik instans ini ke representasi string yang setara menggunakan format yang ditentukan dan informasi format khusus budaya.
public:
virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);public string ToString (string format, IFormatProvider provider);public string ToString (string? format, IFormatProvider? provider);override this.ToString : string * IFormatProvider -> stringPublic Function ToString (format As String, provider As IFormatProvider) As StringParameter
- format
- String
String format numerik.
- provider
- IFormatProvider
Objek yang memasok informasi pemformatan khusus budaya.
Mengembalikan
Representasi string dari nilai instans ini seperti yang ditentukan oleh format dan provider.
Penerapan
Contoh
Contoh berikut menampilkan Double nilai menggunakan masing-masing penentu format numerik standar yang didukung untuk beberapa budaya yang berbeda.
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 %
Contoh berikut mengilustrasikan penggunaan ToString, mengambil String dan IFormatProvider sebagai parameter.
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
Keterangan
Metode memformat ToString(String, IFormatProvider)Double nilai dalam format tertentu dari budaya tertentu. Jika Anda ingin menentukan format atau budaya yang berbeda, gunakan kelebihan beban ToString metode lainnya, sebagai berikut:
| Untuk menggunakan format | Untuk budaya | Menggunakan kelebihan beban |
|---|---|---|
| Format default ("G") | Kultur default (saat ini) | ToString() |
| Format default ("G") | Budaya tertentu | ToString(IFormatProvider) |
| Format atau presisi tertentu | Kultur default (saat ini) | ToString(String) |
Nilai yang dikembalikan dapat berupa PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, atau representasi string dari angka, seperti yang ditentukan oleh format.
Parameter format dapat berupa penentu format numerik standar yang valid kecuali untuk D dan X, serta kombinasi penentu format numerik kustom. Jika format adalah null atau string kosong, nilai yang dikembalikan untuk instans ini diformat dengan penentu format numerik umum ("G").
.NET menyediakan dukungan pemformatan ekstensif, yang dijelaskan secara lebih rinci dalam topik pemformatan berikut:
Untuk informasi selengkapnya tentang penentu format numerik, lihat String Format Numerik Standar dan String Format Numerik Kustom.
Untuk informasi selengkapnya tentang pemformatan, lihat Jenis Pemformatan.
Parameter provider adalah IFormatProvider implementasi yang metodenya GetFormat mengembalikan NumberFormatInfo objek . Biasanya, provider adalah CultureInfo objek atau NumberFormatInfo objek. Parameter provider memasok informasi khusus budaya yang digunakan dalam pemformatan. Jika provider adalah null, nilai yang dikembalikan diformat menggunakan NumberFormatInfo objek untuk budaya saat ini.
Secara default, nilai pengembalian hanya berisi 15 digit presisi meskipun maksimum 17 digit dipertahankan secara internal. Jika nilai instans ini memiliki lebih besar dari 15 digit, ToString mengembalikan atau NegativeInfinitySymbol alih-alih PositiveInfinitySymbol angka yang diharapkan. Jika Anda memerlukan lebih banyak presisi, tentukan format dengan spesifikasi format "G17", yang selalu mengembalikan 17 digit presisi, atau "R", yang mengembalikan 15 digit jika angka dapat diwakili dengan presisi tersebut atau 17 digit jika angka hanya dapat diwakili dengan presisi maksimum.
Catatan Bagi Pemanggil
Dalam beberapa kasus, nilai Double yang diformat dengan string format numerik standar "R" tidak berhasil melakukan format dua arah jika dikompilasi menggunakan /platform:x64 atau /platform:anycpu beralih dan berjalan pada sistem 64-bit. Untuk mengatasi masalah ini, Anda dapat memformat Double nilai dengan menggunakan string format numerik standar "G17". Contoh berikut menggunakan string format "R" dengan Double nilai yang tidak berhasil melakukan round-trip, dan juga menggunakan string format "G17" untuk berhasil melakukan round-trip nilai asli.
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
Lihat juga
- Parse(String)
- Tipe Pemformatan di .NET
- String Format Numerik Standar
- String Format Numerik Kustom
- Cara: Mem-Padding Angka dengan Awalan Nol
- Sampel: Utilitas Pemformatan .NET Core WinForms (C#)
- Sampel: Utilitas Pemformatan .NET Core WinForms (Visual Basic)
Berlaku untuk
.NET 9 dan versi lainnya
| Produk | Versi |
|---|---|
| .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 |
Berkolaborasi dengan kami di GitHub
Sumber untuk konten ini dapat ditemukan di GitHub, yang juga dapat Anda gunakan untuk membuat dan meninjau masalah dan menarik permintaan. Untuk informasi selengkapnya, lihat panduan kontributor kami.
Umpan balik .NET
.NET adalah proyek sumber terbuka. Pilih tautan untuk memberikan umpan balik: