Double.ToString Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
Aşırı Yüklemeler
| ToString() |
Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür. |
| ToString(IFormatProvider) |
Bu örneğin sayısal değerini belirtilen kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür. |
| ToString(String) |
Bu örneğin sayısal değerini, belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür. |
| ToString(String, IFormatProvider) |
Bu örneğin sayısal değerini belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür. |
ToString()
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
public:
override System::String ^ ToString();public override string ToString ();override this.ToString : unit -> stringPublic Overrides Function ToString () As StringDöndürülenler
Bu örneğin değerinin dize olarak gösterimi.
Örnekler
Aşağıdaki örnek, bir dizi Double değerin dize gösterimlerini görüntülemek için varsayılan Double.ToString() yöntemi kullanır.
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())
Aşağıdaki örnekte kullanımı gösterilmektedir 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
Açıklamalar
yöntemi, ToString() bir Double değeri geçerli kültürün varsayılan ("G" veya genel) biçiminde biçimlendirir. Farklı bir biçim, duyarlık veya kültür belirtmek istiyorsanız yöntemin diğer aşırı yüklemelerini ToString aşağıdaki gibi kullanın:
| Biçimi kullanmak için | Kültür için | Aşırı yüklemeyi kullanma |
|---|---|---|
| Varsayılan ("G") biçimi | Belirli bir kültür | ToString(IFormatProvider) |
| Belirli bir biçim veya duyarlık | Varsayılan (geçerli) kültür | ToString(String) |
| Belirli bir biçim veya duyarlık | Belirli bir kültür | ToString(String, IFormatProvider) |
Dönüş değeri , NegativeInfinitySymbol, NaNSymbolveya formun bir dizesi olabilirPositiveInfinitySymbol:
[sign]integral-digits[.[ fractional-digits]][E[sign]exponential-digits]
İsteğe bağlı öğeler çerçeve ve köşeli ayraç içine alınır ([ve]). "Rakamlar" terimini içeren öğeler 0-9 arasında bir dizi sayısal karakterden oluşur. Aşağıdaki tabloda listelenen öğeler desteklenir.
| Öğe | Açıklama |
|---|---|
| sign | Eksi işareti ve artı işareti simgesi. |
| tamsayı basamaklar | Sayının tamsayı kısmını belirten rakam dizisi. Kesirli basamaklar varsa tamsayı basamaklar bulunmayabilir. |
| '.' | Bir kültüre özgü ondalık nokta sembolü. |
| kesirli basamaklar | Sayının kesirli bölümü belirten rakam dizisi. |
| 'E' | Üstel (bilimsel) gösterimi gösteren büyük harfli 'E' karakteri. |
| üstel basamaklar | Bir üssü belirten rakam dizisi. |
Dönüş değerinin bazı örnekleri şunlardır: "100", "-123.456.789", "123.45E+6", "500", "3.1416", "600", "-0.123" ve "-Infinity".
.NET, aşağıdaki biçimlendirme konularında daha ayrıntılı olarak açıklanan kapsamlı biçimlendirme desteği sağlar:
Sayısal biçim tanımlayıcıları hakkında daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.
Biçimlendirme hakkında daha fazla bilgi için bkz . Biçimlendirme Türleri.
Ayrıca bkz.
Şunlara uygulanır
ToString(IFormatProvider)
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
Bu örneğin sayısal değerini belirtilen kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.
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 StringParametreler
- provider
- IFormatProvider
Kültüre özgü biçimlendirme bilgileri sağlayan nesne.
Döndürülenler
tarafından providerbelirtilen bu örneğin değerinin dize gösterimi.
Uygulamalar
Örnekler
Aşağıdaki örnekte, birkaç farklı kültürü temsil eden nesneler kullanılarak CultureInfo iki Double değerin dize gösterimi görüntülenir.
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
Aşağıdaki örnekte, parametresi ve IFormatProvider parametresini alarak String kullanımı ToStringgösterilmektedir.
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
Açıklamalar
yöntemi, ToString(IFormatProvider) bir Double değeri belirtilen kültürün varsayılan ("G" veya genel) biçiminde biçimlendirir. Farklı bir biçim veya kültür belirtmek istiyorsanız yönteminin diğer aşırı yüklemelerini ToString aşağıdaki gibi kullanın:
| Biçimi kullanmak için | Kültür için | Aşırı yüklemeyi kullanma |
|---|---|---|
| Varsayılan ("G") biçimi | Varsayılan (geçerli) | ToString() |
| Belirli bir biçim veya duyarlık | Varsayılan (geçerli) kültür | ToString(String) |
| Belirli bir biçim veya duyarlık | Belirli bir kültür | ToString(String, IFormatProvider) |
Dönüş değeri , NegativeInfinitySymbol, NaNSymbolveya formun bir dizesi olabilirPositiveInfinitySymbol:
[sign]integral-digits[.[ fractional-digits]][E[sign]exponential-digits]
İsteğe bağlı öğeler çerçeve ve köşeli ayraç içine alınır ([ve]). "Rakamlar" terimini içeren öğeler 0-9 arasında bir dizi sayısal karakterden oluşur. Aşağıdaki tabloda listelenen öğeler desteklenir.
| Öğe | Açıklama |
|---|---|
| sign | Eksi işareti ve artı işareti simgesi. |
| tamsayı basamaklar | Sayının tamsayı kısmını belirten rakam dizisi. Kesirli basamaklar varsa tamsayı basamaklar bulunmayabilir. |
| '.' | Bir kültüre özgü ondalık nokta sembolü. |
| kesirli basamaklar | Sayının kesirli bölümü belirten rakam dizisi. |
| 'E' | Üstel (bilimsel) gösterimi gösteren büyük harfli 'E' karakteri. |
| üstel basamaklar | Bir üssü belirten rakam dizisi. |
Dönüş değerinin bazı örnekleri şunlardır: "100", "-123.456.789", "123.45E+6", "500", "3.1416", "600", "-0.123" ve "-Infinity".
Bu örnek, genel bir sayısal biçim belirteci ("G") ile biçimlendirilir.
.NET, aşağıdaki biçimlendirme konularında daha ayrıntılı olarak açıklanan kapsamlı biçimlendirme desteği sağlar:
Sayısal biçim tanımlayıcıları hakkında daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.
Biçimlendirme hakkında daha fazla bilgi için bkz . Biçimlendirme Türleri.
provider parametresi, yöntemi bir nesnesi döndüren GetFormat bir IFormatProviderNumberFormatInfo uygulamadır. Genellikle bir providerCultureInfo nesne veya nesnedir NumberFormatInfo .
provider parametresi, biçimlendirmede kullanılan kültüre özgü bilgiler sağlar. ise providernull, dönüş değeri geçerli kültür için nesnesi kullanılarak NumberFormatInfo biçimlendirilir.
Ayrıca bkz.
Şunlara uygulanır
ToString(String)
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
Bu örneğin sayısal değerini, belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür.
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 StringParametreler
- format
- String
Bir sayısal biçim dizesi.
Döndürülenler
tarafından formatbelirtilen bu örneğin değerinin dize gösterimi.
Özel durumlar
format geçersizdir.
Örnekler
Aşağıdaki örnek bir sayısal değeri tanımlar ve "C" standart sayısal biçim dizesini kullanarak bunu para birimi değeri olarak ve "N" standart sayısal biçim dizesini kullanarak üç ondalık basamak için sayısal değer olarak biçimlendirir. Sonuç dizeleri en-US kültürünün kuralları kullanılarak biçimlendirilir. Sayısal biçim dizeleri hakkında daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.
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
Aşağıdaki örnek, desteklenen standart sayısal biçim tanımlayıcılarını ve üç özel sayısal biçim dizesini kullanarak çeşitli Double değerleri görüntüler. Bu özel biçim dizelerinden biri, bir değerin baştaki sıfırlarla nasıl doldurulacaklarını Single gösterir. Buna ek olarak, örnekte "R" dışında her standart biçim belirticisi ile duyarlık tanımlayıcıları kullanılır. Duyarlık tanımlayıcılarının değerleri 0 ile 3 arasında değişir. Sayısal değerleri dizelere dönüştürmek için örnekte en-US kültürünün biçimlendirme kuralları kullanılır.
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
Açıklamalar
yöntemi, ToString(String) geçerli kültürün kurallarını kullanarak değeri Double belirtilen biçimde biçimlendirmektedir. Farklı bir biçim veya kültür belirtmek istiyorsanız yönteminin diğer aşırı yüklemelerini ToString aşağıdaki gibi kullanın:
| Biçimi kullanmak için | Kültür için | Aşırı yüklemeyi kullanma |
|---|---|---|
| Varsayılan ("G") biçimi | Varsayılan (geçerli) kültür | ToString() |
| Varsayılan ("G") biçimi | Belirli bir kültür | ToString(IFormatProvider) |
| Belirli bir biçim veya duyarlık | Belirli bir kültür | ToString(String, IFormatProvider) |
Dönüş değeri, tarafından formatbelirtildiği gibi , NegativeInfinitySymbol, NaNSymbolveya bir sayının dize gösterimi olabilirPositiveInfinitySymbol.
format parametresi, D ve X dışında herhangi bir geçerli standart sayısal biçim belirticisi olabileceği gibi, özel sayısal biçim tanımlayıcılarının herhangi bir bileşimi de olabilir.
null ise veya boş bir dizeyseformat, dönüş değeri genel sayısal biçim tanımlayıcısı ("G") ile biçimlendirilir.
.NET, aşağıdaki biçimlendirme konularında daha ayrıntılı olarak açıklanan kapsamlı biçimlendirme desteği sağlar:
Sayısal biçim tanımlayıcıları hakkında daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.
Biçimlendirme hakkında daha fazla bilgi için bkz . Biçimlendirme Türleri.
Varsayılan olarak, en fazla 17 basamak dahili olarak korunsa da, dönüş değeri yalnızca 15 basamak duyarlık içerir. Bu örneğin değeri 15 basamaktan büyükse, ToString beklenen sayı yerine veya NegativeInfinitySymbol döndürürPositiveInfinitySymbol. Daha fazla duyarlık gerekiyorsa, format her zaman 17 duyarlık basamağı döndüren "G17" biçim belirtimi ile belirtin veya sayı bu duyarlıkla gösterilebilirse 15 basamak döndüren "R", sayı yalnızca maksimum duyarlıkla gösterilebiliyorsa 17 basamak döndürür.
Arayanlara Notlar
Bazı durumlarda, Double "R" standart sayısal biçim dizesiyle biçimlendirilmiş değerler, veya /platform:anycpu anahtarları kullanılarak /platform:x64 derlenip 64 bit sistemlerde çalıştırılırsa başarıyla gidiş dönüş yapmaz. Bu soruna geçici bir çözüm olarak, "G17" standart sayısal biçim dizesini kullanarak değerleri biçimlendirebilirsiniz Double . Aşağıdaki örnek, "R" biçim dizesini, başarıyla gidiş dönüş yapmayan bir Double değerle kullanır ve ayrıca özgün değere başarıyla gidiş dönüş yapmak için "G17" biçim dizesini kullanır.
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
Ayrıca bkz.
- Parse(String)
- .NET'te Biçimlendirme Türleri
- Standart Sayısal Biçim Dizeleri
- Özel Sayısal Biçim Dizeleri
- Nasıl yapılır: Bir Sayıyı Baştaki Sıfırlarla Doldurma
Şunlara uygulanır
ToString(String, IFormatProvider)
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
- Kaynak:
- Double.cs
Bu örneğin sayısal değerini belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.
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 StringParametreler
- format
- String
Bir sayısal biçim dizesi.
- provider
- IFormatProvider
Kültüre özgü biçimlendirme bilgileri sağlayan nesne.
Döndürülenler
ve tarafından formatproviderbelirtildiği gibi bu örneğin değerinin dize gösterimi.
Uygulamalar
Örnekler
Aşağıdaki örnekte, birkaç farklı kültür için desteklenen standart sayısal biçim tanımlayıcılarının her birini kullanan bir Double değer görüntülenir.
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 %
Aşağıdaki örnekte, parametresi ve IFormatProvider parametresini alarak String kullanımı ToStringgösterilmektedir.
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
Açıklamalar
yöntemi, ToString(String, IFormatProvider) bir Double değeri belirtilen kültür biçiminde biçimlendirer. Farklı bir biçim veya kültür belirtmek istiyorsanız yönteminin diğer aşırı yüklemelerini ToString aşağıdaki gibi kullanın:
| Biçimi kullanmak için | Kültür için | Aşırı yüklemeyi kullanma |
|---|---|---|
| Varsayılan ("G") biçimi | Varsayılan (geçerli) kültür | ToString() |
| Varsayılan ("G") biçimi | Belirli bir kültür | ToString(IFormatProvider) |
| Belirli bir biçim veya duyarlık | Varsayılan (geçerli) kültür | ToString(String) |
Dönüş değeri, tarafından formatbelirtildiği gibi , NegativeInfinitySymbol, NaNSymbolveya bir sayının dize gösterimi olabilirPositiveInfinitySymbol.
format parametresi, D ve X dışında herhangi bir geçerli standart sayısal biçim belirticisi olabileceği gibi, özel sayısal biçim tanımlayıcılarının herhangi bir bileşimi de olabilir. ise null veya boş bir dizeyseformat, bu örneğin dönüş değeri genel sayısal biçim tanımlayıcısı ("G") ile biçimlendirilir.
.NET, aşağıdaki biçimlendirme konularında daha ayrıntılı olarak açıklanan kapsamlı biçimlendirme desteği sağlar:
Sayısal biçim tanımlayıcıları hakkında daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.
Biçimlendirme hakkında daha fazla bilgi için bkz . Biçimlendirme Türleri.
provider parametresi, yöntemi bir nesnesi döndüren GetFormat bir IFormatProviderNumberFormatInfo uygulamadır. Genellikle bir providerCultureInfo nesne veya nesnedir NumberFormatInfo .
provider parametresi, biçimlendirmede kullanılan kültüre özgü bilgiler sağlar. ise providernull, dönüş değeri geçerli kültür için nesnesi kullanılarak NumberFormatInfo biçimlendirilir.
Varsayılan olarak, en fazla 17 basamak dahili olarak korunsa da, dönüş değeri yalnızca 15 basamak duyarlık içerir. Bu örneğin değeri 15 basamaktan büyükse, ToString beklenen sayı yerine veya NegativeInfinitySymbol döndürürPositiveInfinitySymbol. Daha fazla duyarlık gerekiyorsa, format her zaman 17 duyarlık basamağı döndüren "G17" biçim belirtimi ile belirtin veya sayı bu duyarlıkla gösterilebilirse 15 basamak döndüren "R", sayı yalnızca maksimum duyarlıkla gösterilebiliyorsa 17 basamak döndürür.
Arayanlara Notlar
Bazı durumlarda, Double "R" standart sayısal biçim dizesiyle biçimlendirilmiş değerler, veya /platform:anycpu anahtarları kullanılarak /platform:x64 derlenip 64 bit sistemlerde çalıştırılırsa başarıyla gidiş dönüş yapmaz. Bu soruna geçici bir çözüm olarak, "G17" standart sayısal biçim dizesini kullanarak değerleri biçimlendirebilirsiniz Double . Aşağıdaki örnek, "R" biçim dizesini, başarıyla gidiş dönüş yapmayan bir Double değerle kullanır ve ayrıca özgün değere başarıyla gidiş dönüş yapmak için "G17" biçim dizesini kullanır.
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
Ayrıca bkz.
- Parse(String)
- .NET'te Biçimlendirme Türleri
- Standart Sayısal Biçim Dizeleri
- Özel Sayısal Biçim Dizeleri
- Nasıl yapılır: Bir Sayıyı Baştaki Sıfırlarla Doldurma
- Örnek: .NET Core WinForms Biçimlendirme Yardımcı Programı (C#)
- Örnek: .NET Core WinForms Biçimlendirme Yardımcı Programı (Visual Basic)
Şunlara uygulanır
GitHub'da bizimle işbirliği yapın
Bu içeriğin kaynağı GitHub'da bulunabilir; burada ayrıca sorunları ve çekme isteklerini oluşturup gözden geçirebilirsiniz. Daha fazla bilgi için katkıda bulunan kılavuzumuzu inceleyin.
