Standardmäßige Zahlenformatzeichenfolgen

Artikel
06/08/2023

Standardformatzeichenfolgen für Zahlen werden für die Formatierung allgemeiner numerischer Typen verwendet. Eine Standardformatzeichenfolge für Zahlen besitzt das Format [format specifier][precision specifier], wobei:

Ein Formatspezifizierer ist ein einzelnes alphabetisches Zeichen, das die Art des Zahlenformats (beispielsweise Währung oder Prozent) angibt. Jede Zahlenformatzeichenfolge, die mehr als ein alphabetisches Zeichen (einschließlich Leerzeichen) enthält, wird als benutzerdefinierte Zahlenformatzeichenfolge interpretiert. Weitere Informationen finden Sie unter Benutzerdefinierte Zahlenformatzeichenfolgen.
Ein Genauigkeitsspezifizierer ist eine optionale ganze Zahl, die sich auf die Anzahl von Stellen in der resultierenden Zeichenfolge auswirkt. Ab .NET 7 liegt der maximale Genauigkeitswert bei 999.999.999. In .NET 6 liegt der maximale Wert für die Genauigkeit bei Int32.MaxValue. In älteren .NET-Versionen kann die Genauigkeit zwischen 0 und 99 liegen. Die Genauigkeitsangabe steuert die Anzahl der Ziffern in der Zeichenfolgendarstellung einer Zahl. Die Zahl selbst wird nicht gerundet. Verwenden Sie für einen Rundungsvorgang die Math.Ceiling-, Math.Floor- oder Math.Round-Methode.

Wenn der Genauigkeitsspezifizierer die Anzahl von Dezimalstellen in der Ergebniszeichenfolge steuert, gibt die Ergebniszeichenfolge eine Zahl an, die auf ein darstellbares Ergebnis gerundet wird, das am ehesten dem unendlich präzisen Ergebnis entspricht. Wenn zwei gleich nahe darstellbare Ergebnisse vorhanden sind:
- Im .NET Framework und in .NET Core bis .NET Core 2.0 wählt die Runtime das Ergebnis mit der größeren am wenigsten signifikanten Ziffer aus (d.h. MidpointRounding.AwayFromZero).
- In .NET Core 2.1 und höher wählt die Runtime das Ergebnis mit einer geraden am wenigsten signifikanten Ziffer aus (d.h. MidpointRounding.ToEven).
Hinweis

Der Genauigkeitsspezifizierer bestimmt Anzahl von Ziffern in der Ergebniszeichenfolge. Verwenden zum Auffüllen einer Ergebniszeichenfolge mit führenden oder nachgestellten Leerzeichen die Funktion für die zusammengesetzte Formatierung, und definieren Sie eine Ausrichtungskomponente im Formatelement.

Standardmäßige Zahlenformatzeichenfolgen werden von Folgendem unterstützt:

Einigen Überladungen der ToString-Methode aller numerischen Typen. Sie können z.B. eine numerische Formatzeichenfolge an die Int32.ToString(String)-Methode und Int32.ToString(String, IFormatProvider)-Methode übergeben.
Die TryFormat-Methode aller numerischen Typen (beispielsweise Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) und Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)).
Dem .NET-Feature für die kombinierte Formatierung, die von einigen Write-Methoden und WriteLine-Methoden der Console-Klasse und der StreamWriter-Klasse, der String.Format-Methode und der StringBuilder.AppendFormat-Methode verwendet wird. Die Funktion für kombinierte Formatierung ermöglicht es Ihnen, die Zeichenfolgendarstellung mehrerer Datenelemente in eine einzelne Zeichenfolge einzuschließen, die Feldbreite anzugeben und die Zahlen in einem Feld auszurichten. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung.
Interpolierten Zeichenfolgen in C# und Visual Basic, die im Vergleich zu Zeichenfolgen im kombinierten Format eine vereinfachte Syntax bereitstellen.

Tipp

Sie können das Hilfsprogramm zur Formatierung herunterladen. Dabei handelt sich um eine Windows Forms-Anwendung für .NET Core, mit der Sie Formatzeichenfolgen auf numerische Werte oder Datums- und Zeitwerte anwenden und die Ergebniszeichenfolge anzeigen können. Für C# und Visual Basic ist Quellcode verfügbar.

Standardformatspezifizierer

Die folgenden Tabelle beschreibt die standardmäßigen Zahlenformatbezeichner und zeigt eine Beispielausgabe an, die von den einzelnen Formatbezeichnern erstellt wird. Weitere Informationen zur Verwendung numerischer Standardformatzeichenfolgen finden Sie im Abschnitt Hinweise, und der Abschnitt Codebeispiel enthält eine ausführliche Abbildung ihrer Verwendung.

Das Ergebnis einer formatierten Zeichenfolge für eine bestimmte Kultur kann von den folgenden Beispielen abweichen. Betriebssystemeinstellungen, Benutzereinstellungen, Umgebungsvariablen und die verwendete .NET-Version können sich auf das Format auswirken. Beispielsweise versucht .NET ab .NET 5, kulturelle Formate plattformübergreifend zu vereinheitlichen. Weitere Informationen finden Sie unter .NET-Globalisierung und ICU.

Formatbezeichner	name	BESCHREIBUNG	Beispiele
"B" oder "b"	Binär	Ergebnis: Eine binäre Zeichenfolge. Unterstützt von: Nur ganzzahlige Typen (.NET 8) Genauigkeitsspezifizierer: Anzahl von Ziffern in der Ergebniszeichenfolge Weitere Informationen: Spezifizierer für Binärformat (B)	42 ("B") -> 101010 255 ("b16") -> 0000000011111111
"C" oder "c"	Währung	Ergebnis: Ein Währungswert Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: Anzahl der Dezimalstellen Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.CurrencyDecimalDigits definiert Weitere Informationen finden Sie unter: Der Währungsformatspezifizierer „C“	123.456 ("C", en-US) -> \$123.46 123.456 ("C", fr-FR) -> 123,46 € 123.456 ("C", ja-JP) -> ¥123 -123.456 ("C3", en-US) -> (\$123.456) -123.456 ("C3", fr-FR) -> -123,456 € -123.456 ("C3", ja-JP) -> -¥123.456
"D" oder "d"	Decimal	Ergebnis: Ganzzahlige Ziffern mit optionalem Minuszeichen Unterstützt von: ausschließlich integralen Typen Genauigkeitsspezifizierer: Mindestanzahl von Ziffern Standardgenauigkeitsspezifizierer: Mindestanzahl von erforderlichen Ziffern Weitere Informationen finden Sie unter: Der Dezimalformatspezifizierer „D“	1234 ("D") -> 1234 -1234 ("D6") -> -001234
"E" oder "e"	Exponential (wissenschaftlich)	Ergebnis: Exponentialschreibweise Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: Anzahl der Dezimalstellen Standardgenauigkeitsspezifizierer: 6. Weitere Informationen finden Sie unter: Der Exponentialformatspezifizierer „E“	1052.0329112756 ("E", en-US) -> 1.052033E+003 1052.0329112756 ("e", fr-FR) -> 1,052033e+003 -1052.0329112756 ("e2", en-US) -> -1.05e+003 -1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" oder "f"	Festkomma	Ergebnis: Ganzzahlen und Dezimalzahlen mit optionalem Minuszeichen Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: Anzahl der Dezimalstellen Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiert Weitere Informationen finden Sie unter: Der Festkommaformatspezifizierer „F“	1234.567 ("F", en-US) -> 1234.57 1234.567 ("F", de-DE) -> 1234,57 1234 ("F1", en-US) -> 1234.0 1234 ("F1", de-DE) -> 1234,0 -1234.56 ("F4", en-US) -> -1234.5600 -1234.56 ("F4", de-DE) -> -1234,5600
"G" oder "g"	Allgemein	Ergebnis: Die kompaktere Festkomma- oder wissenschaftliche Schreibweise. Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: Anzahl der signifikanten Ziffern. Standardgenauigkeitsspezifizierer: abhängig vom numerischen Typ Weitere Informationen finden Sie unter: Der allgemeine Formatspezifizierer „G“	-123.456 ("G", en-US) -> -123.456 -123.456 ("G", sv-SE) -> -123,456 123.4546 ("G4", en-US) -> 123.5 123.4546 ("G4", sv-SE) -> 123,5 -1.234567890e-25 ("G", en-US) -> -1.23456789E-25 -1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" oder "n"	Anzahl	Ergebnis: Ganzzahlen und Dezimalzahlen, Gruppentrennzeichen und ein Dezimaltrennzeichen mit optionalem Minuszeichen Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: gewünschte Anzahl der Dezimalstellen Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiert Weitere Informationen finden Sie unter: Der numerische Formatspezifizierer „N“	1234.567 ("N", en-US) -> 1,234.57 1234.567 ("N", ru-RU) -> 1 234,57 1234 ("N1", en-US) -> 1,234.0 1234 ("N1", ru-RU) -> 1 234,0 -1234.56 ("N3", en-US) -> -1,234.560 -1234.56 ("N3", ru-RU) -> -1 234,560
"P" oder "p"	Prozent	Ergebnis: Die Zahl multipliziert mit 100 und mit einem Prozentzeichen versehen Unterstützt von: allen numerischen Typen Genauigkeitsspezifizierer: gewünschte Anzahl der Dezimalstellen Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.PercentDecimalDigits definiert Weitere Informationen finden Sie unter: Der Prozentformatspezifizierer „P“	1 ("P", en-US) -> 100.00 % 1 ("P", fr-FR) -> 100,00 % -0.39678 ("P1", en-US) -> -39.7 % -0.39678 ("P1", fr-FR) -> -39,7 %
"R" oder "r"	Schleife	Ergebnis: Eine Zeichenfolge, die eine Schleife zu einem identischen Wert ausführen kann Unterstützt von: Single, Double und BigInteger. Hinweis: Wird ausschließlich für den Typ BigInteger empfohlen. Verwenden Sie für Double-Typen „G17“ und für Single-Typen „G9“. Genauigkeitsspezifizierer: Ignoriert. Weitere Informationen finden Sie unter: Der Roundtripformatspezifizierer „R“	123456789.12345678 ("R") -> 123456789.12345678 -1234567890.12345678 ("R") -> -1234567890.1234567
"X" oder "x"	Hexadezimal	Ergebnis: Eine hexadezimale Zeichenfolge Unterstützt von: ausschließlich integralen Typen Genauigkeitsspezifizierer: Anzahl von Ziffern in der Ergebniszeichenfolge Weitere Informationen: Spezifizierer für Hexadezimalformat	255 ("X") -> FF -1 ("x") -> ff 255 ("x4") -> 00ff -1 ("X4") -> 00FF
Jedes andere einzelne Zeichen	Unbekannter Bezeichner	Ergebnis: Löst zur Laufzeit eine FormatException-Ausnahme aus.

Verwenden numerischer Standardformatzeichenfolgen

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.

Eine numerische Standardformatzeichenfolge kann verwendet werden, um die Formatierung eines numerischen Werts auf eine der folgenden Arten zu definieren:

Er kann an die TryFormat-Methode oder an eine Überladung der ToString-Methode übergeben werden, die über einen format-Parameter verfügt. Im folgenden Beispiel wird ein numerischer Wert in der aktuellen Kultur (in diesem Fall „en-US“) als Währungszeichenfolge formatiert.

Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

Die Zeichenfolge kann als formatString-Argument in einem Formatelement angegeben werden, das beispielsweise mit den Methoden String.Format, Console.WriteLine und StringBuilder.AppendFormat verwendet wird. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung. Im folgenden Beispiel wird ein Währungswert mit einem Formatelement in eine Zeichenfolge eingefügt.

Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

decimal value = 123.456m;
Console.WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

Dim value As Decimal = 123.456d
Console.WriteLine("Your account balance is {0:C2}.", value)
' Displays "Your account balance is $123.46."

Optional können Sie ein alignment-Argument bereitstellen, um die Breite des numerischen Felds anzugeben und festzulegen, ob sein Wert rechts- oder linksbündig ausgerichtet ist. Im folgenden Beispiel wird ein Währungswert in einem 28-stelligen Feld linksbündig und ein Währungswert in einem 14-stelligen Feld rechtsbündig ausgerichtet.

array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                            static_cast<Decimal>(18794.16) };
Console::WriteLine("   Beginning Balance           Ending Balance");
Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16

decimal[] amounts = { 16305.32m, 18794.16m };
Console.WriteLine("   Beginning Balance           Ending Balance");
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16

Dim amounts() As Decimal = {16305.32d, 18794.16d}
Console.WriteLine("   Beginning Balance           Ending Balance")
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
' Displays:
'        Beginning Balance           Ending Balance
'        $16,305.32                      $18,794.16

Die Zeichenfolge kann als formatString-Argument in einem interpolierten Ausdruckselement einer interpolierten Zeichenfolge bereitgestellt werden. Weitere Informationen finden Sie im Artikel Zeichenfolgeninterpolation der C#-Referenz oder im Artikel Interpolierte Zeichenfolgen in der Visual Basic-Referenz.

Die folgenden Abschnitte enthalten ausführliche Informationen zu den einzelnen numerischen Standardformatzeichenfolgen.

Spezifizierer für Binärformat (B)

Der Spezifizierer für das Binärformat ("B") konvertiert eine Zahl in eine Zeichenfolge aus Binärziffern. Dieses Format wird nur für integrale Datentypen und erst ab .NET 8 unterstützt.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts nicht beeinflusst.

Spezifizierer für Währungsformat (C)

Mit dem Währungsformatbezeichner "C" wird eine Zahl in eine Zeichenfolge konvertiert, die einen Währungswert darstellt. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen in der Ergebniszeichenfolge an. Wenn die Genauigkeitsangabe fehlt, wird die Standardgenauigkeit von der NumberFormatInfo.CurrencyDecimalDigits-Eigenschaft definiert.

Wenn der zu formatierende Wert mehr als die angegebene oder die standardmäßige Anzahl von Dezimalstellen aufweist, wird der Bruchwert in der Ergebniszeichenfolge gerundet. Wenn der Wert rechts von der Anzahl angegebener Dezimalstellen 5 oder größer ist, wird die letzte Ziffer in der Ergebniszeichenfolge in positiver Richtung gerundet.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst. In der folgenden Tabelle sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der zurückgegebenen Zeichenfolge steuern.

NumberFormatInfo-Eigenschaft	Beschreibung
CurrencyPositivePattern	Definiert die Platzierung des Währungssymbols für positive Werte.
CurrencyNegativePattern	Definiert die Platzierung des Währungssymbols für negative Werte und gibt an, ob das Minuszeichen durch Klammern oder durch die NegativeSign-Eigenschaft dargestellt wird.
NegativeSign	Definiert das verwendete Minuszeichen, wenn CurrencyNegativePattern angibt, dass keine Klammern verwendet werden.
CurrencySymbol	Definiert das Währungssymbol.
CurrencyDecimalDigits	Definiert die Standardanzahl von Dezimalstellen in einem Währungswert. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.
CurrencyDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.
CurrencyGroupSeparator	Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.
CurrencyGroupSizes	Definiert die Anzahl von ganzzahligen Ziffern, die in einer Gruppe angezeigt werden.

Im folgenden Beispiel wird ein Double-Wert mit dem Währungsformatbezeichner formatiert:

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3",
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Spezifizierer für Dezimalformat (D)

Der Dezimalformatbezeichner "D" konvertiert Zahl wird in eine Zeichenfolge aus Dezimalzahlen (0-9), der ein Minuszeichen vorangestellt wird, wenn es sich um eine negative Zahl handelt. Dieses Format wird nur bei ganzzahligen Typen unterstützt.

Die Genauigkeitsangabe gibt die gewünschte Mindestanzahl von Ziffern für die resultierende Zeichenfolge an. Bei Bedarf werden links von der Zahl Nullen ergänzt, um die durch die Genauigkeitsangabe bestimmte Anzahl von Ziffern zu erstellen. Bei fehlender Genauigkeitsangabe wird standardmäßig der zur Darstellung der ganzen Zahl ohne führende Nullen erforderliche Minimalwert zugrunde gelegt.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst. Wie die folgende Tabelle zeigt, wirkt sich eine einzelne Eigenschaft auf die Formatierung der Ergebniszeichenfolge aus.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.

Im folgenden Beispiel wird ein Int32-Wert mit dem Dezimalformatbezeichner formatiert.

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345

int value;

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345

Dim value As Integer

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Spezifizierer für Exponentialformat (E)

Der Exponentialformatbezeichner "E" konvertiert eine Zahl in eine Zeichenfolge, die folgende Form aufweist: "-d.ddd…E+ddd" oder "-d.ddd…e+ddd". Jedes "d" in der Zeichenfolge steht dabei für eine Ziffer (0-9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist. Es steht immer genau eine Ziffer vor dem Dezimaltrennzeichen.

Die Genauigkeitsangabe gibt die gewünschte Anzahl von Ziffern nach dem Dezimaltrennzeichen an. Wenn die Genauigkeitsangabe fehlt, werden als Standard sechs Ziffern nach dem Dezimaltrennzeichen angegeben.

Die Groß- oder Kleinschreibung des Formatbezeichners gibt an, ob dem Exponenten ein "E" oder ein "e" vorangestellt wird. Der Exponent besteht immer aus einem Plus- oder Minuszeichen und mindestens drei Ziffern. Der Exponent wird ggf. durch Nullen ergänzt, um diesem Mindestwert zu entsprechen.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl sowohl für den Koeffizienten als auch für den Exponenten negativ ist.
NumberDecimalSeparator	Definiert die Zeichenfolge, die die ganzzahlige Ziffer von Dezimalstellen im Koeffizienten trennt.
PositiveSign	Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

Im folgenden Beispiel wird ein Double-Wert mit dem Exponentialformatbezeichner formatiert:

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Spezifizierer für Festkommaformat (F)

Der Festkommaformatbezeichner „F“ konvertiert eine Zahl in eine Zeichenfolge, die folgende Form aufweist: „-ddd.ddd…“. Jedes „d“ in der Zeichenfolge steht dabei für eine Ziffer (0–9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist.

Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen an. Bei fehlender Genauigkeitsangabe wird die numerische Genauigkeit von der NumberFormatInfo.NumberDecimalDigits-Eigenschaft angegeben.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst. In der folgenden Tabelle sind die Eigenschaften des NumberFormatInfo-Objekts aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.
NumberDecimalDigits	Definiert die Standardanzahl von Dezimalzahlen. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.

Im folgenden Beispiel wird ein Double-Wert und ein Int32-Wert mit dem Festkommaformatbezeichner formatiert:

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199

int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199

Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199

Spezifizierer für allgemeines Format (G)

Der allgemeine Formatbezeichner „G“ konvertiert eine Zahl abhängig von ihrem Typ und dem Vorhandensein eines Genauigkeitsspezifizierer in die kompaktere Festkomma- oder wissenschaftliche Schreibweise. Die Genauigkeitsangabe definiert die maximale Anzahl von signifikanten Stellen, die in der Ergebniszeichenfolge angezeigt werden können. Wenn die Genauigkeitsangabe fehlt oder 0 (null) ist, wird die Standardgenauigkeit über den Typ der Zahl festgelegt (siehe folgende Tabelle).

Numerischer Typ	Standardgenauigkeit
Byte oder SByte	3 Stellen
Int16 oder UInt16	5 Stellen
Int32 oder UInt32	10 Stellen
Int64	19 Stellen
UInt64	20 Stellen
BigInteger	Unbegrenzt (identisch mit „R“)
Half	Kleinste Roundtrip-fähige Anzahl von Stellen zur Darstellung der Zahl
Single	Kleinste Roundtrip-fähige Anzahl von Stellen zur Darstellung der Zahl (Standardeinstellung in .NET Framework: G7)
Double	Kleinste Roundtrip-fähige Anzahl von Stellen zur Darstellung der Zahl (Standardeinstellung in .NET Framework: G15)
Decimal	Kleinste Roundtrip-fähige Anzahl von Stellen zur Darstellung der Zahl

Die Festkommanotation wird verwendet, wenn der Exponent, der sich durch Ausdrücken der Zahl in wissenschaftlicher Notation ergibt, größer als –5 und kleiner als die Genauigkeitsangabe ist. Andernfalls wird die wissenschaftliche Notation verwendet. Das Ergebnis enthält ggf. ein Dezimaltrennzeichen. Nachfolgende Nullen nach dem Dezimaltrennzeichen werden weggelassen. Wenn die Genauigkeitsangabe vorhanden ist und die Anzahl der signifikanten Ziffern im Ergebnis die angegebene Genauigkeit übersteigt, werden die überzähligen nachfolgenden Ziffern durch Rundung entfernt.

Wenn die Zahl jedoch eine Decimal ist und kein Genauigkeitsspezifizierer angegeben wurde, wird die Festkommanotation in jedem Fall verwendet und nachfolgende Nullen bleiben erhalten.

Bei Verwendung der wissenschaftlichen Notation wird dem Exponenten im Ergebnis "E" vorangestellt, wenn der Formatbezeichner "G" ist, oder "e", wenn der Formatbezeichner "g" ist. Der Exponent enthält mindestens zwei Ziffern. Dies stellt einen Unterschied zum wissenschaftlichen Notationsformat dar, das vom exponentiellen Formatbezeichner erzeugt wird und mindestens drei Ziffern im Exponenten verwendet.

Bei Verwendung mit einem Double-Wert stellt der Formatspezifizierer "G17" sicher, dass für den ursprünglichen Double-Wert erfolgreich Roundtrips durchgeführt werden. Grund hierfür ist, dass es sich bei Double um eine mit IEEE 754-2008 konforme Gleitkommazahl mit doppelter Genauigkeit (binary64) handelt, die bis zu 17 signifikante Stellen aufweist. In .NET Framework empfiehlt es sich, ihn anstelle des Formatspezifizierers "R" zu verwenden, da "R" in einigen Fällen keine Roundtrips für Gleitkommawerte mit doppelter Genauigkeit durchführen kann.

Bei Verwendung mit einem Single-Wert stellt der Formatbezeichner „G9“ sicher, dass der ursprüngliche Single-Wert erfolgreich Roundtrips durchführt. Grund hierfür ist, dass es sich bei Single um eine mit IEEE 754-2008 konforme Gleitkommazahl mit einfacher Genauigkeit (binary32) handelt, die bis zu neun signifikante Stellen aufweist. Aus Leistungsgründen wird empfohlen, dass dies der Verwendung des Formatbezeichners „R“ vorziehen.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst. In der folgenden Tabellen sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.
PositiveSign	Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem allgemeinen Formatbezeichner formatiert:

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416

double number;

number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416

Dim number As Double

number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416

Spezifizierer für numerisches Format (N)

Der numerische Formatbezeichner ("N") konvertiert eine Zahl in eine Zeichenfolge mit dem Format "-d,ddd,ddd.ddd…", wobei "-" ggf. ein negatives Zahlensymbol, "d" eine Ziffer (0-9), "'," ein Gruppentrennzeichen und "." ein Dezimaltrennzeichensymbol angibt. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Ziffern nach dem Dezimaltrennzeichen an. Bei fehlender Genauigkeitsangabe wird die Anzahl der Dezimalstellen von der aktuellen NumberFormatInfo.NumberDecimalDigits-Eigenschaft definiert.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberNegativePattern	Definiert das Format von negativen Werten und gibt an, ob das Minuszeichen durch Klammern oder durch die NegativeSign-Eigenschaft dargestellt wird.
NumberGroupSizes	Definiert die Anzahl von ganzzahligen Ziffern, die zwischen Gruppentrennzeichen angezeigt werden.
NumberGroupSeparator	Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.
NumberDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.
NumberDecimalDigits	Definiert die Standardanzahl von Dezimalzahlen. Dieser Wert kann mit einer Genauigkeitsangabe überschrieben werden.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Zahlenformatbezeichner formatiert:

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0

double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0

Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0

Spezifizierer für Prozentformat (P)

Der Prozentformatbezeichner "P" multipliziert eine Zahl mit 100 und konvertiert sie in eine Zeichenfolge, die einen Prozentsatz darstellt. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen an. Bei fehlender Genauigkeitsangabe wird die Standardgenauigkeit für Zahlen verwendet, die von der aktuellen PercentDecimalDigits-Eigenschaft angegeben wird.

In der folgenden Tabelle sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der zurückgegebenen Zeichenfolge steuern.

NumberFormatInfo-Eigenschaft	Beschreibung
PercentPositivePattern	Definiert die Platzierung des Prozentsymbols für positive Werte.
PercentNegativePattern	Definiert die Platzierung des Prozentsymbols sowie des Minuszeichens für negative Werte.
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
PercentSymbol	Definiert das Prozentsymbol.
PercentDecimalDigits	Definiert die Standardanzahl von Dezimalstellen in einem Prozentwert. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.
PercentDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.
PercentGroupSeparator	Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.
PercentGroupSizes	Definiert die Anzahl von ganzzahligen Ziffern, die in einer Gruppe angezeigt werden.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Prozentformatbezeichner formatiert:

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %

double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %

Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Spezifizierer für Roundtripformat (R)

Der Formatbezeichner für Roundtrips „R“ stellt sicher, dass ein in eine Zeichenfolge konvertierter numerischer Wert wieder in denselben numerischen Wert zurück konvertiert wird. Dieses Format wird nur für folgende Typen unterstützt: Half, Single, Double und BigInteger.

In .NET Framework und in .NET Core-Versionen vor 3.0 kann der Formatspezifizierer "R" in einigen Fällen keine Roundtrips für Double-Werte durchführen. Bei Double- und Single-Werten bietet der Formatspezifizierer "R" eine relativ schlechte Leistung. Stattdessen empfehlen wir zur erfolgreichen Durchführung von Roundtrips für Single-Werte, den Formatbezeichner „G17“ für Double-Werte und den Formatbezeichner „G9“ zu verwenden.

Wenn ein BigInteger-Wert mit diesem Bezeichner formatiert wird, enthält seine Zeichenfolgendarstellung alle signifikanten Stellen im BigInteger-Wert.

Eine Genauigkeitsangabe kann zwar vorhanden sein, sie wird jedoch ignoriert. Bei diesem Bezeichner hat die Rückkonvertierbarkeit höhere Priorität als die Genauigkeit. Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst. In der folgenden Tabellen sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft	Beschreibung
NegativeSign	Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator	Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.
PositiveSign	Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

Im folgenden Beispiel wird ein BigInteger-Wert mit dem Roundtripformatbezeichner formatiert.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249

Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249

Wichtig

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. Weitere Informationen erhalten Sie im folgenden Abschnitt.

Um das Problem zu umgehen, dass für Double-Werte, die mit der numerischen Standardformatzeichenfolgen "R" formatiert wurden, beim Kompilieren mit dem Schalter /platform:x64 oder /platform:anycpu sowie bei Ausführung auf 64-Bit-Systemen kein erfolgreicher Roundtrip möglich ist, können Sie Double-Werte mit der numerischen Standardformatzeichenfolgen "G17" formatieren. 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:

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

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

Spezifizierer für Hexadezimalformat (X)

Der Hexadezimal-Formatbezeichner "X" konvertiert eine Zahl in eine Zeichenfolge von Hexadezimalzahlen. Die Schreibweise des Formatbezeichners gibt an, ob Groß- oder Kleinbuchstaben für Hexadezimalzahlen verwendet werden sollen, die größer als 9 sind. Verwenden Sie z. B. "X" für "ABCDEF", und "x" für "abcdef". Dieses Format wird nur bei ganzzahligen Typen unterstützt.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts nicht beeinflusst.

Im folgenden Beispiel wird Int32-Werte mit dem Hexadezimal-Formatbezeichner formatiert.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15

int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15

Dim value As Integer

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Hinweise

Dieser Abschnitt enthält zusätzliche Informationen zur Verwendung numerischer Standardformatzeichenfolgen.

Einstellungen der Systemsteuerung

Die Einstellungen der Regions- und Sprachoptionen in der Systemsteuerung beeinflussen die durch einen Formatierungsvorgang erstellte Ergebniszeichenfolge. Mithilfe dieser Einstellungen wird das NumberFormatInfo-Objekt initialisiert, das der aktuellen Kultur zugeordnet ist. Dadurch werden Werte zur Steuerung der Formatierung bereitgestellt. Auf Computern mit anderen Einstellungen werden andere Ergebniszeichenfolgen generiert.

Wenn der CultureInfo(String)-Konstruktor verwendet wird, um ein neues CultureInfo-Objekt zu instanziieren, das dieselbe Kultur repräsentiert wie die aktuelle Systemkultur, werden darüber hinaus alle Anpassungen, die über die Einstellung Regions- und Sprachoptionen in der Systemsteuerung eingerichtet werden, auf das neue CultureInfo-Objekt angewendet. Sie können den CultureInfo(String, Boolean) -Konstruktor verwenden, um ein CultureInfo -Objekt zu erstellen, das die Anpassungen eines Systems nicht wiedergibt.

NumberFormatInfo-Eigenschaften

Die Formatierung wird durch die Eigenschaften des aktuellen NumberFormatInfo-Objekts beeinflusst, das implizit durch die aktuelle Kultur oder explizit durch den IFormatProvider-Parameter der Methode bereitgestellt wird, die die Formatierung aufruft. Geben Sie ein NumberFormatInfo-Objekt oder ein CultureInfo-Objekt für diesen Parameter an.

Hinweis

Informationen zum Anpassen der Muster oder Zeichenfolgen, die beim Formatieren der numerischer Werte verwendet werden, finden Sie im Thema zur NumberFormatInfo-Klasse.

Ganzzahlige numerische Typen und numerische Gleitkommatypen

Einige Beschreibungen standardmäßiger Zahlenformatbezeichner verweisen auf ganzzahlige numerische Typen oder numerische Gleitkommatypen. Die ganzzahligen numerischen Typen sind Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 und BigInteger. Die numerischen Gleitkommatypen sind Decimal, Half, Single und Double.

Unendlichkeiten und NaN bei Gleitkommawerten

Wenn der Wert eines Half-, Single- oder Double-Gleitkommatyps positiv unendlich, negativ unendlich oder nicht numerisch (Not a Number, NaN) ist, handelt es sich bei der formatierten Zeichenfolge unabhängig von der Formatzeichenfolge um den Wert der entsprechenden PositiveInfinitySymbol-, NegativeInfinitySymbol- oder NaNSymbol-Eigenschaft, die durch das derzeit gültige NumberFormatInfo-Objekt angegeben wird.

Codebeispiel

Durch das folgende Beispiel werden mithilfe der Kultur en-US und allen Standardzahlen-Formatbezeichnern ein ganzzahliger Wert und ein numerischer Gleitkommawert formatiert. In diesem Beispiel werden zwei bestimmte numerische Typen (Double und Int32) verwendet. Die Ergebnisse sind jedoch für alle numerischen Basistypen (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, Half und Single) ähnlich.

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}",
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}",
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}",
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"
Console.WriteLine("G: {0}",
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}",
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}",
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}",
        floating.ToString("R", ci));           // Displays "R: 10761.937554"
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // Displays "D: 008395"
Console.WriteLine("E: {0}",
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}",
        integral.ToString("F01", ci));         // Displays "F: 8395.0"
Console.WriteLine("G: {0}",
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}",
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}",
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 10761.937554
        Console.WriteLine("C: {0}", _
                floating.ToString("C", ci))           ' Displays "C: $10,761.94"
        Console.WriteLine("E: {0}", _
                floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
        Console.WriteLine("F: {0}", _
                floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
        Console.WriteLine("G: {0}", _
                floating.ToString("G", ci))           ' Displays "G: 10761.937554"
        Console.WriteLine("N: {0}", _
                floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
        Console.WriteLine("P: {0}", _
                (floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
        Console.WriteLine("R: {0}", _
                floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
        Console.WriteLine()

        ' Output integral values
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' Displays "D: 008395" 
        Console.WriteLine("E: {0}", _
                integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
        Console.WriteLine("F: {0}", _
                integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
        Console.WriteLine("G: {0}", _
                integral.ToString("G", ci))           ' Displays "G: 8395"
        Console.WriteLine("N: {0}", _
                integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
        Console.WriteLine("P: {0}", _
                (integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module