Double.ToString Methode
Definition
Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation.
Überlädt
| ToString(String, IFormatProvider) |
Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information. |
| ToString(String) |
Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.Converts the numeric value of this instance to its equivalent string representation, using the specified format. |
| ToString(IFormatProvider) |
Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information. |
| ToString() |
Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation. |
ToString(String, IFormatProvider)
Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.
public:
virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);public string ToString (string format, IFormatProvider provider);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
Eine numerische Formatierungszeichenfolge.A numeric format string.
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.
Gibt zurück
Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von format und provider.The string representation of the value of this instance as specified by format and provider.
Implementiert
Beispiele
Im folgenden Beispiel wird ein Double Wert mit jedem der unterstützten numerischen Standardformat Bearbeiter für verschiedene Kulturen angezeigt.The following example displays a Double value using each of the supported standard numeric format specifiers for several different cultures.
using namespace System;
using namespace System::Globalization;
int main(array<System::String ^> ^args)
{
double value = 16325.62901;
String^ specifier;
CultureInfo^ culture;
// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo::CreateSpecificCulture("eu-ES");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325,62901
Console::WriteLine(value.ToString(specifier, CultureInfo::InvariantCulture));
// Displays: 16325.62901
specifier = "C";
culture = CultureInfo::CreateSpecificCulture("en-US");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: $16,325.63
culture = CultureInfo::CreateSpecificCulture("en-GB");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: £16,325.63
specifier = "E04";
culture = CultureInfo::CreateSpecificCulture("sv-SE");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
culture = CultureInfo::CreateSpecificCulture("en-NZ");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 1.6326E+004
specifier = "F";
culture = CultureInfo::CreateSpecificCulture("fr-FR");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325,63
culture = CultureInfo::CreateSpecificCulture("en-CA");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16325.63
specifier = "N";
culture = CultureInfo::CreateSpecificCulture("es-ES");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16.325,63
culture = CultureInfo::CreateSpecificCulture("fr-CA");
Console::WriteLine(value.ToString(specifier, culture));
// Displays: 16 325,63
specifier = "P";
culture = CultureInfo::InvariantCulture;
Console::WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.26 %
culture = CultureInfo::CreateSpecificCulture("ar-EG");
Console::WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.256 %
return 0;
}
double value = 16325.62901;
string specifier;
CultureInfo culture;
// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays: 16325.62901
specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: £16,325.63
specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
culture = CultureInfo.CreateSpecificCulture("en-NZ");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1.6326E+004
specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16325.63
specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 16 325,63
specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays: 163.256 %
Dim value As Double = 16325.62901
Dim specifier As String
Dim culture As CultureInfo
' Use standard numeric format specifiers.
specifier = "G"
culture = CultureInfo.CreateSpecificCulture("eu-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture))
' Displays: 16325.62901
specifier = "C"
culture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: £16,325.63
specifier = "E04"
culture = CultureInfo.CreateSpecificCulture("sv-SE")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1,6326E+004
culture = CultureInfo.CreateSpecificCulture("en-NZ")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1.6326E+004
specifier = "F"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16325.63
specifier = "N"
culture = CultureInfo.CreateSpecificCulture("es-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 16 325,63
specifier = "P"
culture = CultureInfo.InvariantCulture
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays: 163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG")
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays: 163.256 %
Das folgende Beispiel veranschaulicht die Verwendung von ToString , wobei ein String und ein IFormatProvider als Parameter verwendet werden.The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.
public ref class Temperature: public IFormattable
{
// IFormattable.ToString implementation.
public:
virtual String^ ToString( String^ format, IFormatProvider^ provider )
{
if ( format != nullptr )
{
if ( format->Equals( "F" ) )
{
return String::Format( "{0}'F", this->Value.ToString() );
}
if ( format->Equals( "C" ) )
{
return String::Format( "{0}'C", this->Celsius.ToString() );
}
}
return m_value.ToString( format, provider );
}
protected:
// The value holder
double m_value;
public:
property double Value
{
double get()
{
return m_value;
}
void set( double value )
{
m_value = value;
}
}
property double Celsius
{
double get()
{
return (m_value - 32.0) / 1.8;
}
void set( double value )
{
m_value = 1.8 * value + 32.0;
}
}
};
public class Temperature : IFormattable {
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
Public Class Temperature
Implements IFormattable
Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
Implements IFormattable.ToString
If Not (format Is Nothing) Then
If format.Equals("F") Then
Return [String].Format("{0}'F", Me.Value.ToString())
End If
If format.Equals("C") Then
Return [String].Format("{0}'C", Me.Celsius.ToString())
End If
End If
Return m_value.ToString(format, provider)
End Function
' The value holder
Protected m_value As Double
Public Property Value() As Double
Get
Return m_value
End Get
Set(ByVal Value As Double)
m_value = Value
End Set
End Property
Public Property Celsius() As Double
Get
Return (m_value - 32) / 1.8
End Get
Set(ByVal Value As Double)
m_value = Value * 1.8 + 32
End Set
End Property
End Class
Hinweise
Die- ToString(String, IFormatProvider) Methode formatiert einen Double Wert in einem angegebenen Format einer angegebenen Kultur.The ToString(String, IFormatProvider) method formats a Double value in a specified format of a specified culture. Wenn Sie ein anderes Format oder eine andere Kultur angeben möchten, verwenden Sie die anderen über Ladungen der- ToString Methode wie folgt:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| So verwenden Sie das FormatTo use format | Für KulturFor culture | Verwenden der ÜberladungUse the overload |
|---|---|---|
| Standardformat ("G")Default ("G") format | Standard Kultur (aktuell)Default (current) culture | ToString() |
| Standardformat ("G")Default ("G") format | Eine bestimmte KulturA specific culture | ToString(IFormatProvider) |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Standard Kultur (aktuell)Default (current) culture | ToString(String) |
Der Rückgabewert kann PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol oder die Zeichen folgen Darstellung einer Zahl sein, wie von angegeben format .The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.
Der format -Parameter kann ein beliebiger gültiger numerischer Standardformat Bezeichner mit Ausnahme von D und X sowie eine beliebige Kombination von benutzerdefinierten numerischen Format Bezeichnern sein.The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. Wenn format null oder eine leere Zeichenfolge ist, wird der Rückgabewert für diese Instanz mit dem allgemeinen numerischen Format Bezeichner ("G") formatiert.If format is null or an empty string, the return value for this instance is formatted with the general numeric format specifier ("G").
.Net bietet umfangreiche Formatierungs Unterstützung, die in den folgenden Formatierungs Themen ausführlicher beschrieben wird:.NET provides extensive formatting support, which is described in greater detail in the following formatting topics:
Weitere Informationen zu numerischen Format Bezeichnerzeichen finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Weitere Informationen zur Formatierung finden Sie unter Formatieren von Typen.For more information about formatting, see Formatting Types.
Der- provider Parameter ist eine IFormatProvider Implementierung, deren- GetFormat Methode ein-Objekt zurückgibt NumberFormatInfo .The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. In der Regel provider ist ein- CultureInfo Objekt oder ein- NumberFormatInfo Objekt.Typically, provider is a CultureInfo object or a NumberFormatInfo object. Der- provider Parameter liefert kulturspezifische Informationen, die bei der Formatierung verwendet werden.The provider parameter supplies culture-specific information used in formatting. Wenn provider null den Wert hat, wird der Rückgabewert mit dem- NumberFormatInfo Objekt für die aktuelle Kultur formatiert.If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.
Standardmäßig enthält der Rückgabewert nur 15 Dezimalstellen, obwohl intern ein Maximum von 17 Ziffern beibehalten wird.By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. Wenn der Wert dieser Instanz größer als 15 Ziffern ist, wird ToString PositiveInfinitySymbol oder NegativeInfinitySymbol anstelle der erwarteten Zahl zurückgegeben.If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. Wenn Sie mehr Genauigkeit benötigen, geben Sie format mit der Format Spezifikation "G17" an, die immer 17 Ziffern der Genauigkeit zurückgibt, oder "R", die 15 Ziffern zurückgibt, wenn die Zahl mit dieser Genauigkeit oder 17 Ziffern dargestellt werden kann, wenn die Zahl nur mit maximaler Genauigkeit dargestellt werden kann.If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.
Hinweise für Aufrufer
In einigen Fällen werden Double-Werte, die mit der Standardformatzeichenfolge für Zahlen "R" formatiert sind, nicht erfolgreich zurückkonvertiert, wenn sie mit dem /platform:x64- oder dem /platform:anycpu-Parameter kompiliert wurden und auf 64-Bit-Systemen ausgeführt werden.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Um dieses Problem zu umgehen, formatieren Sie Double-Werte mit der Standardformatzeichenfolge für Zahlen "G17".To work around this problem, you can format Double values by using the "G17" standard numeric format string. Im folgenden Beispiel wird die Formatzeichenfolge "R" mit einem Double-Wert verwendet, der nicht erfolgreich zurückkonvertiert wird, und es wird die Formatzeichenfolge "G17" verwendet, um erfolgreich in den ursprünglichen Wert zurückzukonvertieren.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.
::: Code language = "CSharp" Source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/System. Double. ToString/CS/roundtripex1. cs "Interactive =" try-dotnet "ID =" Snippet5 ":::::: Code language =" vb "Source =" ~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/System. Double. ToString/VB/roundtripex1. vb "ID =" Snippet5 "::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.Double.ToString/cs/roundtripex1.cs" interactive="try-dotnet" id="Snippet5"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.Double.ToString/vb/roundtripex1.vb" id="Snippet5":::
Siehe auch
- Parse(String)
- Formatieren von Typen in .NETFormatting Types in .NET
- Standardmäßige ZahlenformatzeichenfolgenStandard Numeric Format Strings
- Benutzerdefinierte ZahlenformatzeichenfolgenCustom Numeric Format Strings
- Vorgehensweise: Auffüllen einer Zahl mit führenden NullenHow to: Pad a Number with Leading Zeros
- Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)Sample: .NET Core WinForms Formatting Utility (C#)
- Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)Sample: .NET Core WinForms Formatting Utility (Visual Basic)
Gilt für:
ToString(String)
Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.Converts the numeric value of this instance to its equivalent string representation, using the specified format.
public:
System::String ^ ToString(System::String ^ format);public string ToString (string format);public string ToString (string? format);override this.ToString : string -> stringPublic Function ToString (format As String) As StringParameter
- format
- String
Eine numerische Formatierungszeichenfolge.A numeric format string.
Gibt zurück
Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von format.The string representation of the value of this instance as specified by format.
Ausnahmen
format ist ungültig.format is invalid.
Beispiele
Im folgenden Beispiel wird ein numerischer Wert definiert und als Währungswert formatiert, indem die standardmäßige numerische Format Zeichenfolge "C" und ein numerischer Wert für drei Dezimalstellen mit der standardmäßigen numerischen Format Zeichenfolge "N" verwendet wird.The following example defines a numeric value and formats it as a currency value by using the "C" standard numeric format string and as a numeric value to three decimal places by using the "N" standard numeric format string. Die Ergebnis Zeichenfolgen werden anhand der Konventionen der Kultur "en-US" formatiert.The result strings are formatted by using the conventions of the en-US culture. Weitere Informationen zu numerischen Format Zeichenfolgen finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For more information on numeric format strings, see Standard Numeric Format Strings and Custom Numeric Format Strings.
using System;
public class Example
{
public static void Main()
{
float number = 1764.3789m;
// Format as a currency value.
Console.WriteLine(number.ToString("C"));
// Format as a numeric value with 3 decimal places.
Console.WriteLine(number.ToString("N3"));
}
}
// The example displays the following output:
// $1,764.38
// 1,764.379
Module Example
Public Sub Main()
Dim number As Double = 1764.3789
' Format as a currency value.
Console.WriteLine(number.ToString("C"))
' Format as a numeric value with 3 decimal places.
Console.WriteLine(number.ToString("N3"))
End Sub
End Module
' The example displays the following output:
' $1,764.38
' 1,764.379
Im folgenden Beispiel werden mehrere Double Werte mit den unterstützten numerischen Standardformat Bezeichnerzeichen und drei benutzerdefinierten numerischen Format Zeichenfolgen angezeigt.The following example displays several Double values using the supported standard numeric format specifiers together with three custom numeric format strings. Eine dieser benutzerdefinierten Format Zeichenfolgen veranschaulicht, wie ein Single Wert mit führenden Nullen aufgefüllt wird.One of those custom format strings illustrates how to pad a Single value with leading zeros. Außerdem verwendet das Beispiel genauigkeitsspezifizierer mit jedem Standardformat Bezeichner mit Ausnahme von "R".In addition, the example uses precision specifiers with each standard format specifier except for "R". Die Werte der genauigkeitsspezifizierer liegen zwischen 0 und 3.The values of the precision specifiers range from 0 to 3. Zum Konvertieren der numerischen Werte in Zeichen folgen verwendet das Beispiel die Formatierungs Konventionen der Kultur "en-US".To convert the numeric values to strings, the example uses the formatting conventions of the en-US culture.
using namespace System;
void main()
{
array<Double>^ numbers= {1054.32179, -195489100.8377, 1.0437E21,
-1.0573e-05};
array<String^>^ specifiers = { "C", "E", "e", "F", "G", "N", "P",
"R", "#,000.000", "0.###E-000",
"000,000,000,000.00###" };
for each (Double number in numbers)
{
Console::WriteLine("Formatting of {0}:", number);
for each (String^ specifier in specifiers) {
Console::WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier));
// Add precision specifiers from 0 to 3.
if (specifier->Length == 1 & ! specifier->Equals("R")) {
for (int precision = 0; precision <= 3; precision++) {
String^ pSpecifier = String::Format("{0}{1}", specifier, precision);
Console::WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier));
}
Console::WriteLine();
}
}
Console::WriteLine();
}
}
// The example displays the following output:
// Formatting of 1054.32179:
// C: $1,054.32
// C0: $1,054
// C1: $1,054.3
// C2: $1,054.32
// C3: $1,054.322
//
// E: 1.054322E+003
// E0: 1E+003
// E1: 1.1E+003
// E2: 1.05E+003
// E3: 1.054E+003
//
// e: 1.054322e+003
// e0: 1e+003
// e1: 1.1e+003
// e2: 1.05e+003
// e3: 1.054e+003
//
// F: 1054.32
// F0: 1054
// F1: 1054.3
// F2: 1054.32
// F3: 1054.322
//
// G: 1054.32179
// G0: 1054.32179
// G1: 1E+03
// G2: 1.1E+03
// G3: 1.05E+03
//
// N: 1,054.32
// N0: 1,054
// N1: 1,054.3
// N2: 1,054.32
// N3: 1,054.322
//
// P: 105,432.18 %
// P0: 105,432 %
// P1: 105,432.2 %
// P2: 105,432.18 %
// P3: 105,432.179 %
//
// R: 1054.32179
// #,000.000: 1,054.322
// 0.###E-000: 1.054E003
// 000,000,000,000.00###: 000,000,001,054.32179
//
// Formatting of -195489100.8377:
// C: ($195,489,100.84)
// C0: ($195,489,101)
// C1: ($195,489,100.8)
// C2: ($195,489,100.84)
// C3: ($195,489,100.838)
//
// E: -1.954891E+008
// E0: -2E+008
// E1: -2.0E+008
// E2: -1.95E+008
// E3: -1.955E+008
//
// e: -1.954891e+008
// e0: -2e+008
// e1: -2.0e+008
// e2: -1.95e+008
// e3: -1.955e+008
//
// F: -195489100.84
// F0: -195489101
// F1: -195489100.8
// F2: -195489100.84
// F3: -195489100.838
//
// G: -195489100.8377
// G0: -195489100.8377
// G1: -2E+08
// G2: -2E+08
// G3: -1.95E+08
//
// N: -195,489,100.84
// N0: -195,489,101
// N1: -195,489,100.8
// N2: -195,489,100.84
// N3: -195,489,100.838
//
// P: -19,548,910,083.77 %
// P0: -19,548,910,084 %
// P1: -19,548,910,083.8 %
// P2: -19,548,910,083.77 %
// P3: -19,548,910,083.770 %
//
// R: -195489100.8377
// #,000.000: -195,489,100.838
// 0.###E-000: -1.955E008
// 000,000,000,000.00###: -000,195,489,100.8377
//
// Formatting of 1.0437E+21:
// C: $1,043,700,000,000,000,000,000.00
// C0: $1,043,700,000,000,000,000,000
// C1: $1,043,700,000,000,000,000,000.0
// C2: $1,043,700,000,000,000,000,000.00
// C3: $1,043,700,000,000,000,000,000.000
//
// E: 1.043700E+021
// E0: 1E+021
// E1: 1.0E+021
// E2: 1.04E+021
// E3: 1.044E+021
//
// e: 1.043700e+021
// e0: 1e+021
// e1: 1.0e+021
// e2: 1.04e+021
// e3: 1.044e+021
//
// F: 1043700000000000000000.00
// F0: 1043700000000000000000
// F1: 1043700000000000000000.0
// F2: 1043700000000000000000.00
// F3: 1043700000000000000000.000
//
// G: 1.0437E+21
// G0: 1.0437E+21
// G1: 1E+21
// G2: 1E+21
// G3: 1.04E+21
//
// N: 1,043,700,000,000,000,000,000.00
// N0: 1,043,700,000,000,000,000,000
// N1: 1,043,700,000,000,000,000,000.0
// N2: 1,043,700,000,000,000,000,000.00
// N3: 1,043,700,000,000,000,000,000.000
//
// P: 104,370,000,000,000,000,000,000.00 %
// P0: 104,370,000,000,000,000,000,000 %
// P1: 104,370,000,000,000,000,000,000.0 %
// P2: 104,370,000,000,000,000,000,000.00 %
// P3: 104,370,000,000,000,000,000,000.000 %
//
// R: 1.0437E+21
// #,000.000: 1,043,700,000,000,000,000,000.000
// 0.###E-000: 1.044E021
// 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
// Formatting of -1.0573E-05:
// C: $0.00
// C0: $0
// C1: $0.0
// C2: $0.00
// C3: $0.000
//
// E: -1.057300E-005
// E0: -1E-005
// E1: -1.1E-005
// E2: -1.06E-005
// E3: -1.057E-005
//
// e: -1.057300e-005
// e0: -1e-005
// e1: -1.1e-005
// e2: -1.06e-005
// e3: -1.057e-005
//
// F: 0.00
// F0: 0
// F1: 0.0
// F2: 0.00
// F3: 0.000
//
// G: -1.0573E-05
// G0: -1.0573E-05
// G1: -1E-05
// G2: -1.1E-05
// G3: -1.06E-05
//
// N: 0.00
// N0: 0
// N1: 0.0
// N2: 0.00
// N3: 0.000
//
// P: 0.00 %
// P0: 0 %
// P1: 0.0 %
// P2: 0.00 %
// P3: -0.001 %
//
// R: -1.0573E-05
// #,000.000: 000.000
// 0.###E-000: -1.057E-005
// 000,000,000,000.00###: -000,000,000,000.00001
double[] numbers= {1054.32179, -195489100.8377, 1.0437E21,
-1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P",
"R", "#,000.000", "0.###E-000",
"000,000,000,000.00###" };
foreach (double number in numbers)
{
Console.WriteLine("Formatting of {0}:", number);
foreach (string specifier in specifiers) {
Console.WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier));
// Add precision specifiers from 0 to 3.
if (specifier.Length == 1 & ! specifier.Equals("R")) {
for (int precision = 0; precision <= 3; precision++) {
string pSpecifier = String.Format("{0}{1}", specifier, precision);
Console.WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier));
}
Console.WriteLine();
}
}
Console.WriteLine();
}
// The example displays the following output to the console:
// Formatting of 1054.32179:
// C: $1,054.32
// C0: $1,054
// C1: $1,054.3
// C2: $1,054.32
// C3: $1,054.322
//
// E: 1.054322E+003
// E0: 1E+003
// E1: 1.1E+003
// E2: 1.05E+003
// E3: 1.054E+003
//
// e: 1.054322e+003
// e0: 1e+003
// e1: 1.1e+003
// e2: 1.05e+003
// e3: 1.054e+003
//
// F: 1054.32
// F0: 1054
// F1: 1054.3
// F2: 1054.32
// F3: 1054.322
//
// G: 1054.32179
// G0: 1054.32179
// G1: 1E+03
// G2: 1.1E+03
// G3: 1.05E+03
//
// N: 1,054.32
// N0: 1,054
// N1: 1,054.3
// N2: 1,054.32
// N3: 1,054.322
//
// P: 105,432.18 %
// P0: 105,432 %
// P1: 105,432.2 %
// P2: 105,432.18 %
// P3: 105,432.179 %
//
// R: 1054.32179
// #,000.000: 1,054.322
// 0.###E-000: 1.054E003
// 000,000,000,000.00###: 000,000,001,054.32179
//
// Formatting of -195489100.8377:
// C: ($195,489,100.84)
// C0: ($195,489,101)
// C1: ($195,489,100.8)
// C2: ($195,489,100.84)
// C3: ($195,489,100.838)
//
// E: -1.954891E+008
// E0: -2E+008
// E1: -2.0E+008
// E2: -1.95E+008
// E3: -1.955E+008
//
// e: -1.954891e+008
// e0: -2e+008
// e1: -2.0e+008
// e2: -1.95e+008
// e3: -1.955e+008
//
// F: -195489100.84
// F0: -195489101
// F1: -195489100.8
// F2: -195489100.84
// F3: -195489100.838
//
// G: -195489100.8377
// G0: -195489100.8377
// G1: -2E+08
// G2: -2E+08
// G3: -1.95E+08
//
// N: -195,489,100.84
// N0: -195,489,101
// N1: -195,489,100.8
// N2: -195,489,100.84
// N3: -195,489,100.838
//
// P: -19,548,910,083.77 %
// P0: -19,548,910,084 %
// P1: -19,548,910,083.8 %
// P2: -19,548,910,083.77 %
// P3: -19,548,910,083.770 %
//
// R: -195489100.8377
// #,000.000: -195,489,100.838
// 0.###E-000: -1.955E008
// 000,000,000,000.00###: -000,195,489,100.8377
//
// Formatting of 1.0437E+21:
// C: $1,043,700,000,000,000,000,000.00
// C0: $1,043,700,000,000,000,000,000
// C1: $1,043,700,000,000,000,000,000.0
// C2: $1,043,700,000,000,000,000,000.00
// C3: $1,043,700,000,000,000,000,000.000
//
// E: 1.043700E+021
// E0: 1E+021
// E1: 1.0E+021
// E2: 1.04E+021
// E3: 1.044E+021
//
// e: 1.043700e+021
// e0: 1e+021
// e1: 1.0e+021
// e2: 1.04e+021
// e3: 1.044e+021
//
// F: 1043700000000000000000.00
// F0: 1043700000000000000000
// F1: 1043700000000000000000.0
// F2: 1043700000000000000000.00
// F3: 1043700000000000000000.000
//
// G: 1.0437E+21
// G0: 1.0437E+21
// G1: 1E+21
// G2: 1E+21
// G3: 1.04E+21
//
// N: 1,043,700,000,000,000,000,000.00
// N0: 1,043,700,000,000,000,000,000
// N1: 1,043,700,000,000,000,000,000.0
// N2: 1,043,700,000,000,000,000,000.00
// N3: 1,043,700,000,000,000,000,000.000
//
// P: 104,370,000,000,000,000,000,000.00 %
// P0: 104,370,000,000,000,000,000,000 %
// P1: 104,370,000,000,000,000,000,000.0 %
// P2: 104,370,000,000,000,000,000,000.00 %
// P3: 104,370,000,000,000,000,000,000.000 %
//
// R: 1.0437E+21
// #,000.000: 1,043,700,000,000,000,000,000.000
// 0.###E-000: 1.044E021
// 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
// Formatting of -1.0573E-05:
// C: $0.00
// C0: $0
// C1: $0.0
// C2: $0.00
// C3: $0.000
//
// E: -1.057300E-005
// E0: -1E-005
// E1: -1.1E-005
// E2: -1.06E-005
// E3: -1.057E-005
//
// e: -1.057300e-005
// e0: -1e-005
// e1: -1.1e-005
// e2: -1.06e-005
// e3: -1.057e-005
//
// F: 0.00
// F0: 0
// F1: 0.0
// F2: 0.00
// F3: 0.000
//
// G: -1.0573E-05
// G0: -1.0573E-05
// G1: -1E-05
// G2: -1.1E-05
// G3: -1.06E-05
//
// N: 0.00
// N0: 0
// N1: 0.0
// N2: 0.00
// N3: 0.000
//
// P: 0.00 %
// P0: 0 %
// P1: 0.0 %
// P2: 0.00 %
// P3: -0.001 %
//
// R: -1.0573E-05
// #,000.000: 000.000
// 0.###E-000: -1.057E-005
// 000,000,000,000.00###: -000,000,000,000.00001
Dim numbers() As Double = {1054.32179, -195489100.8377, 1.0437E21, _
-1.0573e-05}
Dim specifiers() As String = { "C", "E", "e", "F", "G", "N", "P", _
"R", "#,000.000", "0.###E-000", _
"000,000,000,000.00###" }
For Each number As Double In numbers
Console.WriteLine("Formatting of {0}:", number)
For Each specifier As String In specifiers
Console.WriteLine(" {0,-22} {1}",
specifier + ":", number.ToString(specifier))
' Add precision specifiers from 0 to 3.
If specifier.Length = 1 And Not specifier.Equals("R") Then
For precision As Integer = 0 To 3
Dim pSpecifier As String = String.Format("{0}{1}", specifier, precision)
Console.WriteLine(" {0,-22} {1}",
pSpecifier + ":", number.ToString(pSpecifier))
Next
Console.WriteLine()
End If
Next
Console.WriteLine()
Next
' The example displays the following output:
' Formatting of 1054.32179:
' C: $1,054.32
' C0: $1,054
' C1: $1,054.3
' C2: $1,054.32
' C3: $1,054.322
'
' E: 1.054322E+003
' E0: 1E+003
' E1: 1.1E+003
' E2: 1.05E+003
' E3: 1.054E+003
'
' e: 1.054322e+003
' e0: 1e+003
' e1: 1.1e+003
' e2: 1.05e+003
' e3: 1.054e+003
'
' F: 1054.32
' F0: 1054
' F1: 1054.3
' F2: 1054.32
' F3: 1054.322
'
' G: 1054.32179
' G0: 1054.32179
' G1: 1E+03
' G2: 1.1E+03
' G3: 1.05E+03
'
' N: 1,054.32
' N0: 1,054
' N1: 1,054.3
' N2: 1,054.32
' N3: 1,054.322
'
' P: 105,432.18 %
' P0: 105,432 %
' P1: 105,432.2 %
' P2: 105,432.18 %
' P3: 105,432.179 %
'
' R: 1054.32179
' #,000.000: 1,054.322
' 0.###E-000: 1.054E003
' 000,000,000,000.00###: 000,000,001,054.32179
'
' Formatting of -195489100.8377:
' C: ($195,489,100.84)
' C0: ($195,489,101)
' C1: ($195,489,100.8)
' C2: ($195,489,100.84)
' C3: ($195,489,100.838)
'
' E: -1.954891E+008
' E0: -2E+008
' E1: -2.0E+008
' E2: -1.95E+008
' E3: -1.955E+008
'
' e: -1.954891e+008
' e0: -2e+008
' e1: -2.0e+008
' e2: -1.95e+008
' e3: -1.955e+008
'
' F: -195489100.84
' F0: -195489101
' F1: -195489100.8
' F2: -195489100.84
' F3: -195489100.838
'
' G: -195489100.8377
' G0: -195489100.8377
' G1: -2E+08
' G2: -2E+08
' G3: -1.95E+08
'
' N: -195,489,100.84
' N0: -195,489,101
' N1: -195,489,100.8
' N2: -195,489,100.84
' N3: -195,489,100.838
'
' P: -19,548,910,083.77 %
' P0: -19,548,910,084 %
' P1: -19,548,910,083.8 %
' P2: -19,548,910,083.77 %
' P3: -19,548,910,083.770 %
'
' R: -195489100.8377
' #,000.000: -195,489,100.838
' 0.###E-000: -1.955E008
' 000,000,000,000.00###: -000,195,489,100.8377
'
' Formatting of 1.0437E+21:
' C: $1,043,700,000,000,000,000,000.00
' C0: $1,043,700,000,000,000,000,000
' C1: $1,043,700,000,000,000,000,000.0
' C2: $1,043,700,000,000,000,000,000.00
' C3: $1,043,700,000,000,000,000,000.000
'
' E: 1.043700E+021
' E0: 1E+021
' E1: 1.0E+021
' E2: 1.04E+021
' E3: 1.044E+021
'
' e: 1.043700e+021
' e0: 1e+021
' e1: 1.0e+021
' e2: 1.04e+021
' e3: 1.044e+021
'
' F: 1043700000000000000000.00
' F0: 1043700000000000000000
' F1: 1043700000000000000000.0
' F2: 1043700000000000000000.00
' F3: 1043700000000000000000.000
'
' G: 1.0437E+21
' G0: 1.0437E+21
' G1: 1E+21
' G2: 1E+21
' G3: 1.04E+21
'
' N: 1,043,700,000,000,000,000,000.00
' N0: 1,043,700,000,000,000,000,000
' N1: 1,043,700,000,000,000,000,000.0
' N2: 1,043,700,000,000,000,000,000.00
' N3: 1,043,700,000,000,000,000,000.000
'
' P: 104,370,000,000,000,000,000,000.00 %
' P0: 104,370,000,000,000,000,000,000 %
' P1: 104,370,000,000,000,000,000,000.0 %
' P2: 104,370,000,000,000,000,000,000.00 %
' P3: 104,370,000,000,000,000,000,000.000 %
'
' R: 1.0437E+21
' #,000.000: 1,043,700,000,000,000,000,000.000
' 0.###E-000: 1.044E021
' 000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
'
' Formatting of -1.0573E-05:
' C: $0.00
' C0: $0
' C1: $0.0
' C2: $0.00
' C3: $0.000
'
' E: -1.057300E-005
' E0: -1E-005
' E1: -1.1E-005
' E2: -1.06E-005
' E3: -1.057E-005
'
' e: -1.057300e-005
' e0: -1e-005
' e1: -1.1e-005
' e2: -1.06e-005
' e3: -1.057e-005
'
' F: 0.00
' F0: 0
' F1: 0.0
' F2: 0.00
' F3: 0.000
'
' G: -1.0573E-05
' G0: -1.0573E-05
' G1: -1E-05
' G2: -1.1E-05
' G3: -1.06E-05
'
' N: 0.00
' N0: 0
' N1: 0.0
' N2: 0.00
' N3: 0.000
'
' P: 0.00 %
' P0: 0 %
' P1: 0.0 %
' P2: 0.00 %
' P3: -0.001 %
'
' R: -1.0573E-05
' #,000.000: 000.000
' 0.###E-000: -1.057E-005
' 000,000,000,000.00###: -000,000,000,000.00001
Hinweise
Die- ToString(String) Methode formatiert einen Double Wert in einem angegebenen Format unter Verwendung der Konventionen der aktuellen Kultur.The ToString(String) method formats a Double value in a specified format by using the conventions of the current culture. Wenn Sie ein anderes Format oder eine andere Kultur angeben möchten, verwenden Sie die anderen über Ladungen der- ToString Methode wie folgt:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| So verwenden Sie das FormatTo use format | Für KulturFor culture | Verwenden der ÜberladungUse the overload |
|---|---|---|
| Standardformat ("G")Default ("G") format | Standard Kultur (aktuell)Default (current) culture | ToString() |
| Standardformat ("G")Default ("G") format | Eine bestimmte KulturA specific culture | ToString(IFormatProvider) |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Eine bestimmte KulturA specific culture | ToString(String, IFormatProvider) |
Der Rückgabewert kann PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol oder die Zeichen folgen Darstellung einer Zahl sein, wie von angegeben format .The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or the string representation of a number, as specified by format.
Der format -Parameter kann ein beliebiger gültiger numerischer Standardformat Bezeichner mit Ausnahme von D und X sowie eine beliebige Kombination von benutzerdefinierten numerischen Format Bezeichnern sein.The format parameter can be any valid standard numeric format specifier except for D and X, as well as any combination of custom numeric format specifiers. Wenn format null oder eine leere Zeichenfolge ist, wird der Rückgabewert mit dem allgemeinen numerischen Format Bezeichner ("G") formatiert.If format is null or an empty string, the return value is formatted with the general numeric format specifier ("G").
.Net bietet umfangreiche Formatierungs Unterstützung, die in den folgenden Formatierungs Themen ausführlicher beschrieben wird:.NET provides extensive formatting support, which is described in greater detail in the following formatting topics:
Weitere Informationen zu numerischen Format Bezeichnerzeichen finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Weitere Informationen zur Formatierung finden Sie unter Formatieren von Typen.For more information about formatting, see Formatting Types.
Standardmäßig enthält der Rückgabewert nur 15 Dezimalstellen, obwohl intern ein Maximum von 17 Ziffern beibehalten wird.By default, the return value only contains 15 digits of precision although a maximum of 17 digits is maintained internally. Wenn der Wert dieser Instanz größer als 15 Ziffern ist, wird ToString PositiveInfinitySymbol oder NegativeInfinitySymbol anstelle der erwarteten Zahl zurückgegeben.If the value of this instance has greater than 15 digits, ToString returns PositiveInfinitySymbol or NegativeInfinitySymbol instead of the expected number. Wenn Sie mehr Genauigkeit benötigen, geben Sie format mit der Format Spezifikation "G17" an, die immer 17 Ziffern der Genauigkeit zurückgibt, oder "R", die 15 Ziffern zurückgibt, wenn die Zahl mit dieser Genauigkeit oder 17 Ziffern dargestellt werden kann, wenn die Zahl nur mit maximaler Genauigkeit dargestellt werden kann.If you require more precision, specify format with the "G17" format specification, which always returns 17 digits of precision, or "R", which returns 15 digits if the number can be represented with that precision or 17 digits if the number can only be represented with maximum precision.
Hinweise für Aufrufer
In einigen Fällen werden Double-Werte, die mit der Standardformatzeichenfolge für Zahlen "R" formatiert sind, nicht erfolgreich zurückkonvertiert, wenn sie mit dem /platform:x64- oder dem /platform:anycpu-Parameter kompiliert wurden und auf 64-Bit-Systemen ausgeführt werden.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Um dieses Problem zu umgehen, formatieren Sie Double-Werte mit der Standardformatzeichenfolge für Zahlen "G17".To work around this problem, you can format Double values by using the "G17" standard numeric format string. Im folgenden Beispiel wird die Formatzeichenfolge "R" mit einem Double-Wert verwendet, der nicht erfolgreich zurückkonvertiert wird, und es wird die Formatzeichenfolge "G17" verwendet, um erfolgreich in den ursprünglichen Wert zurückzukonvertieren.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.
::: Code language = "CSharp" Source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/System. Double. ToString/CS/roundtripex2. cs "Interactive =" try-dotnet "ID =" Snippet6 ":::::: Code language =" vb "Source =" ~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/System. Double. ToString/VB/roundtripex2. vb "ID =" Snippet6 "::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.Double.ToString/cs/roundtripex2.cs" interactive="try-dotnet" id="Snippet6"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.Double.ToString/vb/roundtripex2.vb" id="Snippet6":::
Siehe auch
- Parse(String)
- Formatieren von Typen in .NETFormatting Types in .NET
- Standardmäßige ZahlenformatzeichenfolgenStandard Numeric Format Strings
- Benutzerdefinierte ZahlenformatzeichenfolgenCustom Numeric Format Strings
- Vorgehensweise: Auffüllen einer Zahl mit führenden NullenHow to: Pad a Number with Leading Zeros
Gilt für:
ToString(IFormatProvider)
Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.
public:
virtual System::String ^ ToString(IFormatProvider ^ provider);public:
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
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.An object that supplies culture-specific formatting information.
Gibt zurück
Die Zeichenfolgendarstellung des Werts dieser Instanz entsprechend den Angaben von provider.The string representation of the value of this instance as specified by provider.
Implementiert
Beispiele
Im folgenden Beispiel wird die Zeichen folgen Darstellung von zwei Double Werten mithilfe von-Objekten angezeigt, die CultureInfo verschiedene Kulturen darstellen.The following example displays the string representation of two Double values using CultureInfo objects that represent several different cultures.
double value;
value = -16325.62015;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
value = 16034.125E21;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
// -16325.62015
// -16325.62015
// -16325,62015
// 1.6034125E+25
// 1.6034125E+25
// 1,6034125E+25
Dim value As Double
value = -16325.62015
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
value = 16034.125E21
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
' -16325.62015
' -16325.62015
' -16325,62015
' 1.6034125E+25
' 1.6034125E+25
' 1,6034125E+25
Das folgende Beispiel veranschaulicht die Verwendung von ToString , wobei ein String und ein IFormatProvider als Parameter verwendet werden.The following example illustrates the use of ToString, taking a String and an IFormatProvider as parameters.
public ref class Temperature: public IFormattable
{
// IFormattable.ToString implementation.
public:
virtual String^ ToString( String^ format, IFormatProvider^ provider )
{
if ( format != nullptr )
{
if ( format->Equals( "F" ) )
{
return String::Format( "{0}'F", this->Value.ToString() );
}
if ( format->Equals( "C" ) )
{
return String::Format( "{0}'C", this->Celsius.ToString() );
}
}
return m_value.ToString( format, provider );
}
protected:
// The value holder
double m_value;
public:
property double Value
{
double get()
{
return m_value;
}
void set( double value )
{
m_value = value;
}
}
property double Celsius
{
double get()
{
return (m_value - 32.0) / 1.8;
}
void set( double value )
{
m_value = 1.8 * value + 32.0;
}
}
};
public class Temperature : IFormattable {
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
Public Class Temperature
Implements IFormattable
Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
Implements IFormattable.ToString
If Not (format Is Nothing) Then
If format.Equals("F") Then
Return [String].Format("{0}'F", Me.Value.ToString())
End If
If format.Equals("C") Then
Return [String].Format("{0}'C", Me.Celsius.ToString())
End If
End If
Return m_value.ToString(format, provider)
End Function
' The value holder
Protected m_value As Double
Public Property Value() As Double
Get
Return m_value
End Get
Set(ByVal Value As Double)
m_value = Value
End Set
End Property
Public Property Celsius() As Double
Get
Return (m_value - 32) / 1.8
End Get
Set(ByVal Value As Double)
m_value = Value * 1.8 + 32
End Set
End Property
End Class
Hinweise
Die- ToString(IFormatProvider) Methode formatiert einen Double Wert im Standardformat ("G" oder allgemein) einer angegebenen Kultur.The ToString(IFormatProvider) method formats a Double value in the default ("G", or general) format of a specified culture. Wenn Sie ein anderes Format oder eine andere Kultur angeben möchten, verwenden Sie die anderen über Ladungen der- ToString Methode wie folgt:If you want to specify a different format or culture, use the other overloads of the ToString method, as follows:
| So verwenden Sie das FormatTo use format | Für KulturFor culture | Verwenden der ÜberladungUse the overload |
|---|---|---|
| Standardformat ("G")Default ("G") format | Standard (aktuell)Default (current) | ToString() |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Standard Kultur (aktuell)Default (current) culture | ToString(String) |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Eine bestimmte KulturA specific culture | ToString(String, IFormatProvider) |
Der Rückgabewert kann PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol oder eine Zeichenfolge der folgenden Form sein:The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:
[Sign] ganzzahlige Ziffern [. [ Bruch Ziffern]] [E [Sign] exponentialziffern][sign]integral-digits[.[fractional-digits]][E[sign]exponential-digits]
Optionale Elemente werden in eckige Klammern ([und]) eingeschlossen.Optional elements are framed in square brackets ([ and ]). Elemente, die den Begriff "Ziffern" enthalten, bestehen aus einer Reihe von numerischen Zeichen zwischen 0 und 9.Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. Die in der folgenden Tabelle aufgeführten Elemente werden unterstützt.The elements listed in the following table are supported.
| ElementElement | BESCHREIBUNGDescription |
|---|---|
| signsign | Ein negatives Vorzeichen-oder positives Vorzeichen Symbol.A negative sign or positive sign symbol. |
| ganzzahlige Ziffernintegral-digits | Eine Reihe von Ziffern, die den ganzzahligen Teil der Zahl angibt.A series of digits specifying the integral part of the number. Ganzzahlige Ziffern können nicht vorhanden sein, wenn es sich um Bruch Ziffern handelt.Integral-digits can be absent if there are fractional-digits. |
| '.''.' | Ein kulturspezifisches Dezimaltrennzeichen.A culture-specific decimal point symbol. |
| Bruch Ziffernfractional-digits | Eine Reihe von Ziffern, die den Bruch Teil der Zahl angibt.A series of digits specifying the fractional part of the number. |
| "E"'E' | Ein Großbuchstabe "E", der die exponentielle (wissenschaftliche) Notation angibt.An uppercase character 'E', indicating exponential (scientific) notation. |
| exponentielle Ziffernexponential-digits | Eine Reihe von Ziffern, die einen Exponenten angeben.A series of digits specifying an exponent. |
Einige Beispiele für den Rückgabewert sind "100", "-123.456.789", "123,45 e + 6", "500", "3,1416", "600", "-0,123" und "-Infinity".Some examples of the return value are "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", and "-Infinity".
Diese Instanz ist mit dem allgemeinen numerischen Format Bezeichner ("G") formatiert.This instance is formatted with the general numeric format specifier ("G").
.Net bietet umfangreiche Formatierungs Unterstützung, die in den folgenden Formatierungs Themen ausführlicher beschrieben wird:.NET provides extensive formatting support, which is described in greater detail in the following formatting topics:
Weitere Informationen zu numerischen Format Bezeichnerzeichen finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Weitere Informationen zur Formatierung finden Sie unter Formatieren von Typen.For more information about formatting, see Formatting Types.
Der- provider Parameter ist eine IFormatProvider Implementierung, deren- GetFormat Methode ein-Objekt zurückgibt NumberFormatInfo .The provider parameter is an IFormatProvider implementation whose GetFormat method returns a NumberFormatInfo object. In der Regel provider ist ein- CultureInfo Objekt oder ein- NumberFormatInfo Objekt.Typically, provider is a CultureInfo object or a NumberFormatInfo object. Der- provider Parameter liefert kulturspezifische Informationen, die bei der Formatierung verwendet werden.The provider parameter supplies culture-specific information used in formatting. Wenn provider null den Wert hat, wird der Rückgabewert mit dem- NumberFormatInfo Objekt für die aktuelle Kultur formatiert.If provider is null, the return value is formatted using the NumberFormatInfo object for the current culture.
Siehe auch
Gilt für:
ToString()
Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation.
public:
override System::String ^ ToString();public override string ToString ();override this.ToString : unit -> stringPublic Overrides Function ToString () As StringGibt zurück
Die Zeichenfolgendarstellung des Werts dieser Instanz.The string representation of the value of this instance.
Beispiele
Im folgenden Beispiel wird die-Standard Double.ToString() Methode verwendet, um die Zeichen folgen Darstellungen einer Reihe von Double Werten anzuzeigen.The following example uses the default Double.ToString() method to display the string representations of a number of Double values.
double number;
number = 1.6E20;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());
number = 1.6E2;
// Displays 160.
Console.WriteLine(number.ToString());
number = -3.541;
// Displays -3.541.
Console.WriteLine(number.ToString());
number = -1502345222199E-07;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());
number = -15023452221990199574E-09;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());
number = .60344;
// Displays 0.60344.
Console.WriteLine(number.ToString());
number = .000000001;
// Displays 1E-09.
Console.WriteLine(number.ToString());
Dim number As Double
number = 1.6E20
' Displays 1.6E+20.
Console.WriteLIne(number.ToString())
number = 1.6E2
' Displays 160.
Console.WriteLine(number.ToString())
number = -3.541
' Displays -3.541.
Console.WriteLine(number.ToString())
number = -1502345222199E-07
' Displays -150234.5222199.
Console.WriteLine(number.ToString())
number = -15023452221990199574E-09
' Displays -15023452221.9902.
Console.WriteLine(number.ToString())
number = .60344
' Displays 0.60344.
Console.WriteLine(number.ToString())
number = .000000001
' Displays 1E-09.
Console.WriteLine(number.ToString())
Im folgenden Beispiel wird die Verwendung von ToString veranschaulicht.The following example illustrates the use of ToString.
bool done = false;
String^ inp;
do
{
Console::Write( "Enter a real number: " );
inp = Console::ReadLine();
try
{
d = Double::Parse( inp );
Console::WriteLine( "You entered {0}.", d );
done = true;
}
catch ( FormatException^ )
{
Console::WriteLine( "You did not enter a number." );
}
catch ( Exception^ e )
{
Console::WriteLine( "An exception occurred while parsing your response: {0}", e );
}
}
while ( !done );
bool done = false;
string inp;
do {
Console.Write("Enter a real number: ");
inp = Console.ReadLine();
try {
d = Double.Parse(inp);
Console.WriteLine("You entered {0}.", d.ToString());
done = true;
}
catch (FormatException) {
Console.WriteLine("You did not enter a number.");
}
catch (ArgumentNullException) {
Console.WriteLine("You did not supply any input.");
}
catch (OverflowException) {
Console.WriteLine("The value you entered, {0}, is out of range.", inp);
}
} while (!done);
Dim Done As Boolean = False
Dim Inp As String
Do
Console.Write("Enter a real number: ")
inp = Console.ReadLine()
Try
D = Double.Parse(inp)
Console.WriteLine("You entered " + D.ToString() + ".")
Done = True
Catch e As FormatException
Console.WriteLine("You did not enter a number.")
Catch e As ArgumentNullException
Console.WriteLine("You did not supply any input.")
Catch e As OverflowException
Console.WriteLine("The value you entered, {0}, is out of range.", inp)
End Try
Loop While Not Done
Hinweise
Die- ToString() Methode formatiert einen Double Wert im Standardformat ("G" oder allgemein) der aktuellen Kultur.The ToString() method formats a Double value in the default ("G", or general) format of the current culture. Wenn Sie ein anderes Format, eine andere Genauigkeit oder Kultur angeben möchten, verwenden Sie die anderen über Ladungen der- ToString Methode wie folgt:If you want to specify a different format, precision, or culture, use the other overloads of the ToString method, as follows:
| So verwenden Sie das FormatTo use format | Für KulturFor culture | Verwenden der ÜberladungUse the overload |
|---|---|---|
| Standardformat ("G")Default ("G") format | Eine bestimmte KulturA specific culture | ToString(IFormatProvider) |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Standard Kultur (aktuell)Default (current) culture | ToString(String) |
| Ein bestimmtes Format oder eine bestimmte GenauigkeitA specific format or precision | Eine bestimmte KulturA specific culture | ToString(String, IFormatProvider) |
Der Rückgabewert kann PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol oder eine Zeichenfolge der folgenden Form sein:The return value can be PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol, or a string of the form:
[Sign] ganzzahlige Ziffern [. [ Bruch Ziffern]] [E [Sign] exponentialziffern][sign]integral-digits[.[fractional-digits]][E[sign]exponential-digits]
Optionale Elemente werden in eckige Klammern ([und]) eingeschlossen.Optional elements are framed in square brackets ([ and ]). Elemente, die den Begriff "Ziffern" enthalten, bestehen aus einer Reihe von numerischen Zeichen zwischen 0 und 9.Elements that contain the term "digits" consist of a series of numeric characters ranging from 0 to 9. Die in der folgenden Tabelle aufgeführten Elemente werden unterstützt.The elements listed in the following table are supported.
| ElementElement | BESCHREIBUNGDescription |
|---|---|
| signsign | Ein negatives Vorzeichen-oder positives Vorzeichen Symbol.A negative sign or positive sign symbol. |
| ganzzahlige Ziffernintegral-digits | Eine Reihe von Ziffern, die den ganzzahligen Teil der Zahl angibt.A series of digits specifying the integral part of the number. Ganzzahlige Ziffern können nicht vorhanden sein, wenn es sich um Bruch Ziffern handelt.Integral-digits can be absent if there are fractional-digits. |
| '.''.' | Ein kulturspezifisches Dezimaltrennzeichen.A culture-specific decimal point symbol. |
| Bruch Ziffernfractional-digits | Eine Reihe von Ziffern, die den Bruch Teil der Zahl angibt.A series of digits specifying the fractional part of the number. |
| "E"'E' | Ein Großbuchstabe "E", der die exponentielle (wissenschaftliche) Notation angibt.An uppercase character 'E', indicating exponential (scientific) notation. |
| exponentielle Ziffernexponential-digits | Eine Reihe von Ziffern, die einen Exponenten angeben.A series of digits specifying an exponent. |
Einige Beispiele für den Rückgabewert sind "100", "-123.456.789", "123,45 e + 6", "500", "3,1416", "600", "-0,123" und "-Infinity".Some examples of the return value are "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123", and "-Infinity".
.Net bietet umfangreiche Formatierungs Unterstützung, die in den folgenden Formatierungs Themen ausführlicher beschrieben wird:.NET provides extensive formatting support, which is described in greater detail in the following formatting topics:
Weitere Informationen zu numerischen Format Bezeichnerzeichen finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For more information about numeric format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.
Weitere Informationen zur Formatierung finden Sie unter Formatieren von Typen.For more information about formatting, see Formatting Types.