Freigeben über

Standardmäßige numerische Formatzeichenfolgen

Standardmäßige numerische Formatzeichenfolgen werden verwendet, um allgemeine numerische Typen zu formatieren. Eine standardmäßige numerische Formatzeichenfolge verwendet das Format [format specifier][precision specifier], wobei:

  • Der Formatbezeichner ist ein einzelnes alphabetisches Zeichen, das den Typ des Zahlenformats angibt, z. B. Währung oder Prozent. Jede numerische Formatzeichenfolge, die mehr als ein alphabetisches Zeichen enthält, einschließlich Leerzeichen, wird als benutzerdefinierte numerische Formatzeichenfolge interpretiert. Weitere Informationen finden Sie unter Benutzerdefinierte numerische Formatzeichenfolgen.

  • Der Genauigkeitsbezeichner ist eine optionale ganze Zahl, die sich auf die Anzahl der Ziffern in der resultierenden Zeichenfolge auswirkt. In .NET 7 und höheren Versionen beträgt der Maximale Genauigkeitswert 999.999.999. In .NET 6 lautet Int32.MaxValueder Maximale Genauigkeitswert . In früheren .NET-Versionen kann die Genauigkeit zwischen 0 und 99 liegen. Der Genauigkeitsbezeichner steuert die Anzahl der Ziffern in der Zeichenfolgendarstellung einer Zahl. Sie rundet die Zahl nicht selbst. Verwenden Sie zum Ausführen eines Rundungsvorgangs die Math.Ceiling, oder Math.FloorMath.Round die Methode.

    Wenn der Genauigkeitsbezeichner die Anzahl der Dezimalstellen in der Ergebniszeichenfolge steuert, gibt die Ergebniszeichenfolge eine Zahl wieder, die auf ein repräsentierbares Ergebnis gerundet wird, das dem unendlich genauen Ergebnis am nächsten ist. Wenn zwei gleich nahe darstellbare Ergebnisse vorhanden sind:

    • In .NET Framework und .NET Core bis .NET Core 2.0 wählt die Laufzeit das Ergebnis mit der geringsten Ziffer aus (d. h. mit MidpointRounding.AwayFromZero).
    • In .NET Core 2.1 und höher wählt die Laufzeit das Ergebnis mit einer geraden nicht signifikanten Ziffer (d. h. mit MidpointRounding.ToEven).

    Hinweis

    Der Genauigkeitsbezeichner bestimmt die Anzahl der Ziffern in der Ergebniszeichenfolge. Wenn Sie eine Ergebniszeichenfolge mit führenden oder nachgestellten Leerzeichen auffüllen möchten, verwenden Sie das Zusammengesetztformatierungsfeature , und definieren Sie eine Breitekomponente im Formatelement.

Standardmäßige numerische Formatzeichenfolgen werden von:

Tipp

Sie können das Formatierungsprogramm herunterladen, eine .NET Core Windows Forms-Anwendung, mit der Sie Formatzeichenfolgen auf numerische oder Datums- und Uhrzeitwerte anwenden und die Ergebniszeichenfolge anzeigen können. Quellcode ist für C# und Visual Basic verfügbar.

Standardformatbezeichner

In der folgenden Tabelle werden die standardmäßigen numerischen Formatbezeichner beschrieben und die Beispielausgabe angezeigt, die von jedem Formatbezeichner erzeugt wird. Im Abschnitt "Hinweise " finden Sie weitere Informationen zur Verwendung von standardmäßigen numerischen Formatzeichenfolgen und dem Codebeispielabschnitt für eine umfassende Abbildung ihrer Verwendung.

Das Ergebnis einer formatierten Zeichenfolge für eine bestimmte Kultur kann sich von den folgenden Beispielen unterscheiden. Betriebssystemeinstellungen, Benutzereinstellungen, Umgebungsvariablen und die verwendete .NET-Version können sich alle auf das Format auswirken. Ab .NET 5 versucht .NET beispielsweise, kulturübergreifende Formate zu vereinheitlichen. Weitere Informationen finden Sie unter .NET Globalization und ICU.

Formatbezeichner Name BESCHREIBUNG Beispiele
"B" oder "b" Binär Ergebnis: Eine binäre Zeichenfolge.

Unterstützt von: Nur Integraltypen (.NET 8+).

Genauigkeitsbezeichner: Anzahl der Ziffern in der Ergebniszeichenfolge.

Weitere Informationen: Der Binäre ("B") Formatbezeichner.		 42 ("B")
-> Nr. 101010

255 ("b16")
-> 0000000011111111
"C" oder "c" Währung Ergebnis: Ein Währungswert.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Anzahl der Dezimalziffern.

Standardgenauigkeitsbezeichner: Definiert durch NumberFormatInfo.CurrencyDecimalDigits.

Weitere Informationen: Der Währungsformatbezeichner ("C").		 123,456 ("C", en-US)
-> \123,46 $

123,456 („C“, fr-FR)
- alter Preis:> 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" Dezimalzahl Ergebnis: Ganzzahlige Ziffern mit optionalem negativen Vorzeichen.

Unterstützt von: Nur integrale Typen.

Genauigkeitsbezeichner: Minimale Anzahl von Ziffern.

Standardgenauigkeitsbezeichner: Mindestanzahl der erforderlichen Ziffern.

Weitere Informationen: Der Decimal("D")-Formatbezeichner.		 1234 ("D")
-> 1234

-1234 ("D6")
-> -001234
"E" oder "e" Exponentiell (wissenschaftlich) Ergebnis: Exponentielle Schreibweise.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Anzahl der Dezimalziffern.

Standardgenauigkeitsbezeichner: 6.

Weitere Informationen: Der Exponentielle ("E") Formatbezeichner.		 1052.0329112756 ("E", en-US)
-> 1.052033E+003

1052.0329112756 ("d", fr-FR)
-> 1.052033e+003

-1052.0329112756 ("e2", en-US)
-> -1,05e+003

-1052.0329112756 ("E2", fr-FR)
-> -1,05E+003
"F" oder "f" Fester Punkt Ergebnis: Integrale und Dezimalziffern mit optionalem negativen Vorzeichen.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Anzahl der Dezimalziffern.

Standardgenauigkeitsbezeichner: Definiert durch NumberFormatInfo.NumberDecimalDigits.

Weitere Informationen: Der Fixed-Point ("F") Formatbezeichner.		 1234.567 ("F", en-US)
-> 1234,57 kg

1234,567 ("F", de-DE)
-> 1234,57 kg

1234 ("F1", en-US)
-> 1234,0 kg

1234 ("F1", de-DE)
-> 1234,0 kg

-1234,56 ("F4", en-US)
-> -1234,5600 kg

-1234,56 ("F4", de-DE)
-> -1234.5600
"G" oder "g" Allgemein Ergebnis: Je kompakter die Festkomma- oder wissenschaftliche Schreibweise.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Anzahl der signifikanten Ziffern.

Standardgenauigkeitsbezeichner: Hängt vom numerischen Typ ab.

Weitere Informationen: Der Allgemeine ("G") Formatbezeichner.		 -123,456 ("G", en-US)
-> -123,456

-123.456 („G“, sv-SE)
-> -123.456

123.4546 ("G4", en-US)
-> 123,5 kg

123.4546 ("G4", sv-SE)
-> 123,5 kg

-1.234567890e-25 ("G", en-US)
-> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE)
-> -1.23456789E-25
"N" oder "n" Nummer Ergebnis: Integral- und Dezimalziffern, Gruppentrennzeichen und ein Dezimaltrennzeichen mit optionalem negativen Vorzeichen.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Gewünschte Anzahl von Dezimalstellen.

Standardgenauigkeitsbezeichner: Definiert durch NumberFormatInfo.NumberDecimalDigits.

Weitere Informationen: Der Numerische ("N") Formatbezeichner.		 1234.567 ("N", en-US)
-> 1.234.57

1234,567 ("N", ru-RU)
-> 1 234,57 kg

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: Zahl multipliziert mit 100 und mit einem Prozentsymbol angezeigt.

Unterstützt von: Alle numerischen Typen.

Genauigkeitsbezeichner: Gewünschte Anzahl von Dezimalstellen.

Standardgenauigkeitsbezeichner: Definiert durch NumberFormatInfo.PercentDecimalDigits.

Weitere Informationen: Der Prozentformatbezeichner ("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" Hin- und Rücktransfer Ergebnis: Eine Zeichenfolge, die auf eine identische Zahl gerundet werden kann.

Unterstützt von: Single, Double und BigInteger.

Hinweis: Nur für den BigInteger Typ empfohlen. Double Verwenden Sie für Typen "G17"; verwenden Sie für Single Typen "G9".
Genauigkeitsbezeichner: Ignoriert.

Weitere Informationen: Der Roundtrip ("R") Formatbezeichner.		 123456789.12345678 ("R")
- Artikel-Nr> .: 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" oder "x" Hexadezimal Ergebnis: Eine hexadezimale Zeichenfolge.

Unterstützt von: Nur integrale Typen.

Genauigkeitsbezeichner: Anzahl der Ziffern in der Ergebniszeichenfolge.

Weitere Informationen: Der Hexadezimalformatbezeichner ("X")		 255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Ein beliebiges anderes einzelnes Zeichen Unbekannter Bezeichner Ergebnis: Löst zur Laufzeit ein FormatException .

Verwenden von standardmäßigen numerischen Formatzeichenfolgen

Hinweis

Die C#-Beispiele in diesem Artikel werden im Try.NET Inlinecodeausführung und -playground ausgeführt. Wählen Sie die Schaltfläche "Ausführen " aus, 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 ausführen, indem Sie erneut "Ausführen" auswählen. 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 standardmäßige numerische Formatzeichenfolge kann verwendet werden, um die Formatierung eines numerischen Werts auf eine der folgenden Arten zu definieren:

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

    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

  • Es kann als Argument in einem Formatelement angegeben werden, das formatString mit Methoden wie String.Format, , Console.WriteLineund StringBuilder.AppendFormat. Weitere Informationen finden Sie unter "Zusammengesetzte Formatierung". Im folgenden Beispiel wird ein Formatelement verwendet, um einen Währungswert in eine Zeichenfolge einzufügen.

    decimal value = 123.456m;
Console.WriteLine($"Your account balance is {value:C2}.");
// 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 angeben, um die Breite des numerischen Felds anzugeben und ob der Wert rechts- oder linksbündig ausgerichtet ist. Im folgenden Beispiel wird ein Währungswert in einem 28-stelligen Feld links ausgerichtet und ein Währungswert in einem 14-stelligen Feld rechts ausgerichtet.

    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

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

In den folgenden Abschnitten finden Sie detaillierte Informationen zu den einzelnen standardmäßigen zahlenformatischen Zeichenfolgen.

Binärformatbezeichner (B)

Der Binärformatbezeichner ("B") konvertiert eine Zahl in eine Zeichenfolge mit binären Ziffern. Dieses Format wird nur für integrale Typen und nur für .NET 8+ unterstützt.

Der Genauigkeitsbezeichner gibt die minimale Anzahl der Ziffern an, die in der resultierenden Zeichenfolge gewünscht werden. Falls erforderlich, wird die Zahl mit Nullen links aufgefüllt, um die Anzahl der Ziffern zu erzeugen, die vom Genauigkeitsbezeichner angegeben werden.

Für BigInteger, positive Werte haben immer eine führende Null, um sie von negativen Werten zu unterscheiden. Dadurch wird sichergestellt, dass die Ausgabe-Roundtrips zum ursprünglichen Wert bei der Analyse zurückgegeben werden. Die zahl 3 , die mit dem Formatbezeichner "B2" konvertiert wird, lautet "011"z. B. . Der Grund dafür ist, dass die binäre Zahl "11" den negativen Wert -1darstellt, da sie als Zahl mit genauen 2 Bits aufgrund des "B2" Formats interpretiert wird.

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

Währungsformatbezeichner (C)

Der Formatbezeichner "C" (oder Währungsformat) wandelt eine Zahl in eine Zeichenfolge um, die einen Währungsbetrag darstellt. Der Genauigkeitsbezeichner gibt die gewünschte Anzahl von Dezimalstellen in der Ergebniszeichenfolge an. Wenn der Genauigkeitsbezeichner nicht angegeben wird, wird die Standardgenauigkeit durch die NumberFormatInfo.CurrencyDecimalDigits Eigenschaft definiert.

Wenn der zu formatierte Wert mehr als die angegebene oder Standardanzahl von Dezimalstellen aufweist, wird der Bruchwert in der Ergebniszeichenfolge gerundet. Wenn der Wert rechts neben der Anzahl der angegebenen Dezimalstellen 5 oder größer ist, wird die letzte Ziffer in der Ergebniszeichenfolge von null abgerundet.

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 negative Vorzeichen durch Klammern oder die NegativeSign Eigenschaft dargestellt wird.
NegativeSign Definiert das negative Zeichen, das verwendet wird, wenn CurrencyNegativePattern angegeben wird, dass Klammern nicht verwendet werden.
CurrencySymbol Definiert das Währungssymbol.
CurrencyDecimalDigits Definiert die Standardanzahl von Dezimalziffern in einem Währungswert. Dieser Wert kann mithilfe des Genauigkeitsbezeichners außer Kraft gesetzt werden.
CurrencyDecimalSeparator Definiert die Zeichenfolge, die integrale und dezimale Ziffern trennt.
CurrencyGroupSeparator Definiert die Zeichenfolge, die Gruppen von integralen Zahlen trennt.
CurrencyGroupSizes Definiert die Anzahl ganzzahliger 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
//       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

Dezimalformatbezeichner (D)

Der Formatbezeichner "D" (oder dezimal) konvertiert eine Zahl in eine Zeichenfolge mit Dezimalstellen (0-9), die einem Minuszeichen vorangestellt ist, wenn die Zahl negativ ist. Dieses Format wird nur für integrale Typen unterstützt.

Der Genauigkeitsbezeichner gibt die minimale Anzahl der Ziffern an, die in der resultierenden Zeichenfolge gewünscht werden. Falls erforderlich, wird die Zahl mit Nullen links aufgefüllt, um die Anzahl der Ziffern zu erzeugen, die vom Genauigkeitsbezeichner angegeben werden. Wenn kein Genauigkeitsbezeichner angegeben ist, ist der Standardwert der Mindestwert, der erforderlich ist, um die ganze Zahl ohne führende Nullen darzustellen.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo Objekts beeinflusst. Wie in der folgenden Tabelle dargestellt, 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

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

Exponentieller Formatbezeichner (E)

Der Exponentielle ("E")-Formatbezeichner konvertiert eine Zahl in eine Zeichenfolge des Formulars "-d.ddd... E+ddd" oder "-d.ddd... e+ddd", wobei jede "d" eine Ziffer angibt (0-9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist. Genau eine Ziffer steht immer vor dem Dezimalkomma.

Der Genauigkeitsbezeichner gibt die gewünschte Anzahl von Ziffern nach dem Dezimalkomma an. Wenn der Genauigkeitsbezeichner nicht angegeben wird, wird nach Verwendung des Dezimalkommas ein Standardwert von sechs Ziffern verwendet.

Der Fall des Formatbezeichners gibt an, ob dem Exponenten ein Präfix mit einem "E" oder einem "e" vorangestellt werden soll. Der Exponent besteht immer aus einem Plus- oder Minuszeichen und mindestens drei Ziffern. Der Exponent wird bei Bedarf mit Nullen aufgefüllt, um dieses Minimum zu erfüllen.

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
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 integrale Ziffer von Dezimalziffern im Koeffizienten trennt.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

Im folgenden Beispiel wird ein Double Wert mit dem exponentiellen Formatbezeichner 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

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

Festkommaformatbezeichner (F)

Der Festkommaformatbezeichner ("F") konvertiert eine Zahl in eine Zeichenfolge des Formulars "-ddd.ddd..." wobei jede "d" eine Ziffer angibt (0-9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist.

Der Genauigkeitsbezeichner gibt die gewünschte Anzahl von Dezimalstellen an. Wenn der Genauigkeitsbezeichner nicht angegeben wird, liefert die aktuelle NumberFormatInfo.NumberDecimalDigits Eigenschaft die numerische Genauigkeit.

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

NumberFormatInfo-Eigenschaft BESCHREIBUNG
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator Definiert die Zeichenfolge, die integrale Ziffern von Dezimalziffern trennt.
NumberDecimalDigits Definiert die Standardanzahl von Dezimalziffern. Dieser Wert kann mithilfe des Genauigkeitsbezeichners außer Kraft gesetzt werden.

Im folgenden Beispiel wird ein Double 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

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

Allgemeiner Formatbezeichner (G)

Der allgemeine Formatbezeichner ("G") wandelt eine Zahl je nach Typ der Zahl und ob ein Genauigkeitsbezeichner vorhanden ist, in die kompaktere Schreibweise von Festkomma oder wissenschaftlicher Schreibweise um. Der Genauigkeitsbezeichner definiert die maximale Anzahl signifikanter Ziffern, die in der Ergebniszeichenfolge angezeigt werden können. Wenn der Genauigkeitsbezeichner ausgelassen oder null ist, bestimmt der Typ der Zahl die Standardgenauigkeit, wie in der folgenden Tabelle angegeben.

Numerischer Typ Standardgenauigkeit
Byte oder SByte 3 Ziffern
Int16 oder UInt16 5 Ziffern
Int32 oder UInt32 10 Ziffern
Int64 19 Ziffern
UInt64 20 Ziffern
BigInteger Unbegrenzt (identisch mit "R")
Half Kleinste Roundtrippable-Anzahl von Ziffern, die die Zahl darstellen
Single Kleinste Roundtrippable-Anzahl von Stellen, die die Zahl darstellen (in .NET Framework ist G7 der Standardwert)
Double Kleinste Roundtrippable-Anzahl von Stellen, die die Zahl darstellen (in .NET Framework ist G15 der Standardwert)
Decimal Kleinste Roundtrippable-Anzahl von Ziffern, die die Zahl darstellen

Festkommanotation wird verwendet, wenn der Exponent, der sich aus der Angabe der Zahl in der wissenschaftlichen Schreibweise ergeben würde, größer als -5 und kleiner als der Genauigkeitsbezeichner ist; andernfalls wird die wissenschaftliche Schreibweise verwendet. Das Ergebnis enthält bei Bedarf einen Dezimalkomma, und nachfolgende Nullen nach dem Dezimalkomma werden weggelassen. Wenn der Genauigkeitsbezeichner vorhanden ist und die Anzahl der signifikanten Ziffern im Ergebnis die angegebene Genauigkeit überschreitet, werden die überzähligen nachgestellten Ziffern durch Runden entfernt.

Wenn es sich jedoch um eine Decimal Zahl handelt und der Genauigkeitsbezeichner ausgelassen wird, wird die Notation mit festem Punkt immer verwendet, und nachfolgende Nullen bleiben erhalten.

Wenn die wissenschaftliche Notation verwendet wird, wird dem Exponenten im Ergebnis "E" vorangestellt, wenn der Formatbezeichner "G" oder "e" lautet, wenn der Formatbezeichner "g" ist. Der Exponent enthält mindestens zwei Ziffern. Dies unterscheidet sich vom Format für die wissenschaftliche Notation, die vom exponentiellen Formatbezeichner erzeugt wird, der mindestens drei Ziffern im Exponenten enthält.

Bei Verwendung mit einem Double Wert stellt der Formatbezeichner "G17" sicher, dass der ursprüngliche Double Wert erfolgreich Roundtrips durchführt. Dies liegt daran, dass Double es sich um eine IEEE 754-2008-kompatible Gleitkommazahl (binary64) handelt, die bis zu 17 signifikante Genauigkeitsziffern zurückgibt. In .NET Framework empfehlen wir die Verwendung anstelle des "R"-Formatbezeichners, da in einigen Fällen "R" keine Gleitkommawerte mit doppelter Genauigkeit erfolgreich rundet.

Bei Verwendung mit einem Single Wert stellt der Formatbezeichner "G9" sicher, dass der ursprüngliche Single Wert erfolgreich Roundtrips durchführt. Dies liegt daran, dass Single es sich um eine IEEE 754-2008-kompatible Gleitkommazahl (binary32Single-Precision, Gleitkommazahl) handelt, die bis zu neun signifikante Genauigkeitsziffern zurückgibt. Aus Leistungsgründen empfehlen wir die Verwendung anstelle des "R"-Formatbezeichners.

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 Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft BESCHREIBUNG
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator Definiert die Zeichenfolge, die integrale Ziffern von Dezimalziffern trennt.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

Im folgenden Beispiel werden gleitkommabezogene Werte 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

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

Numerischer Formatbezeichner (N)

Der Numerische ("N")-Formatbezeichner konvertiert eine Zahl in eine Zeichenfolge des Formulars "-d,ddd,ddd.ddd...", wobei "-" bei Bedarf ein negatives Zahlensymbol angibt, "d" eine Ziffer (0-9), "," ein Gruppentrennzeichen und "." gibt ein Dezimalkommasymbol an. Der Genauigkeitsbezeichner gibt die gewünschte Anzahl von Ziffern nach dem Dezimalkomma an. Wenn der Genauigkeitsbezeichner nicht angegeben wird, wird die Anzahl der Dezimalstellen durch die aktuelle NumberFormatInfo.NumberDecimalDigits Eigenschaft definiert.

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 Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft BESCHREIBUNG
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberNegativePattern Definiert das Format negativer Werte und gibt an, ob das negative Zeichen durch Klammern oder die NegativeSign Eigenschaft dargestellt wird.
NumberGroupSizes Definiert die Anzahl der integralen Ziffern, die zwischen Gruppentrennzeichen angezeigt werden.
NumberGroupSeparator Definiert die Zeichenfolge, die Gruppen von integralen Zahlen trennt.
NumberDecimalSeparator Definiert die Zeichenfolge, die integrale und dezimale Ziffern trennt.
NumberDecimalDigits Definiert die Standardanzahl von Dezimalziffern. Dieser Wert kann mithilfe eines Genauigkeitsbezeichners überschrieben werden.

Im folgenden Beispiel werden Gleitkommawerte mit dem Zahlenformatbezeichner wie sortiert 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

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

Prozentformatbezeichner (P)

Der Prozentformatbezeichner ("P") multipliziert eine Zahl um 100 und konvertiert sie in eine Zeichenfolge, die einen Prozentsatz darstellt. Der Genauigkeitsbezeichner gibt die gewünschte Anzahl von Dezimalstellen an. Wenn der Genauigkeitsbezeichner nicht angegeben wird, wird die von der aktuellen PercentDecimalDigits Eigenschaft bereitgestellte standardmäßige numerische Genauigkeit verwendet.

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 und des negativen Symbols für negative Werte.
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
PercentSymbol Definiert das Prozentsymbol.
PercentDecimalDigits Definiert die Standardanzahl von Dezimalziffern in einem Prozentwert. Dieser Wert kann mithilfe des Genauigkeitsbezeichners außer Kraft gesetzt werden.
PercentDecimalSeparator Definiert die Zeichenfolge, die integrale und dezimale Ziffern trennt.
PercentGroupSeparator Definiert die Zeichenfolge, die Gruppen von integralen Zahlen trennt.
PercentGroupSizes Definiert die Anzahl ganzzahliger Ziffern, die in einer Gruppe angezeigt werden.

Im folgenden Beispiel werden 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 %

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 %

Roundtrip-Formatbezeichner (R)

Der Roundtrip -Formatbezeichner ("R") versucht sicherzustellen, dass ein numerischer Wert, der in eine Zeichenfolge konvertiert wird, wieder in denselben numerischen Wert analysiert wird. Dieses Format wird nur für die HalfTypen , Single, und DoubleBigInteger dies unterstützt.

In .NET Framework und in .NET Core-Versionen vor 3.0 schlägt der "R"-Formatbezeichner in einigen Fällen keine erfolgreichen Roundtripwerte Double vor. Sowohl für Werte DoubleSingle als auch für werte bietet der "R"-Formatbezeichner relativ schlechte Leistung. Stattdessen wird empfohlen, den Formatbezeichner "G17" für Double Werte und den "G9" -Formatbezeichner zu verwenden, um Erfolgreich Roundtripwerte Single auszuführen.

Wenn ein BigInteger Wert mit diesem Bezeichner formatiert wird, enthält die Zeichenfolgendarstellung alle signifikanten Ziffern im BigInteger Wert.

Obwohl Sie einen Genauigkeitsbezeichner einschließen können, wird er ignoriert. Roundtrips haben Vorrang vor genauigkeit bei Verwendung dieses Bezeichners. 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 Ergebniszeichenfolge steuern.

NumberFormatInfo-Eigenschaft BESCHREIBUNG
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.
NumberDecimalSeparator Definiert die Zeichenfolge, die integrale Ziffern von Dezimalziffern trennt.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.

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

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

Von Bedeutung

In einigen Fällen werden werte, die mit der standardmäßigen numerischen Formatzeichenfolge "R" formatiert sind, Double nicht erfolgreich gerundet, wenn sie mit den /platform:x64 64-Bit-Systemen kompiliert oder /platform:anycpu kompiliert und ausgeführt werden. Weitere Informationen finden Sie im folgenden Absatz.

Um das Problem von Double Werten zu umgehen, die mit der standardmäßigen numerischen Formatzeichenfolge "R" formatiert sind, die nicht erfolgreich gerundet wird, wenn sie mithilfe der /platform:x64 oder /platform:anycpu der Schalter kompiliert und auf 64-Bit-Systemen ausgeführt wird, können Sie Werte mithilfe der standardmäßigen Zeichenfolge des numerischen Formats "G17" formatieren Double . Im folgenden Beispiel wird die Zeichenfolge "R" mit einem Double Wert verwendet, der nicht erfolgreich gerundet wird, und die Formatzeichenfolge "G17" verwendet, um den ursprünglichen Wert erfolgreich abzurunden:

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($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");

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($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       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':
'       .NET Framework:
'       0.6822871999174 = 0.68228719991740006: False
'       .NET:
'       0.6822871999174 = 0.6822871999174: True
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Hexadezimalformatbezeichner (X)

Der Hexadezimalwert ("X") konvertiert eine Zahl in eine Zeichenfolge mit hexadezimalen Ziffern. Die Groß-/Kleinschreibung des Formatbezeichners gibt an, ob Groß- oder Kleinbuchstaben für Hexadezimalziffern verwendet werden sollen, die größer als 9 sind. Verwenden Sie z. B. "X", um "ABCDEF" und "x" zu produzieren, um "abcdef" zu produzieren. Dieses Format wird nur für integrale Typen unterstützt.

Der Genauigkeitsbezeichner gibt die minimale Anzahl der Ziffern an, die in der resultierenden Zeichenfolge gewünscht werden. Falls erforderlich, wird die Zahl mit Nullen links aufgefüllt, um die Anzahl der Ziffern zu erzeugen, die vom Genauigkeitsbezeichner angegeben werden.

Für BigInteger, positive Werte haben immer eine führende Null, um sie von negativen Werten zu unterscheiden. Dadurch wird sichergestellt, dass die Ausgabe-Roundtrips zum ursprünglichen Wert bei der Analyse zurückgegeben werden. Die zahl F , die mit dem Formatbezeichner "X1" konvertiert wird, liegt 0F beispielsweise daran, dass die hexadezimale Zahl F den negativen Wert -1darstellt.

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

Im folgenden Beispiel werden Werte mit dem Hexadezimalformatbezeichner formatiert Int32 .

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 von standardmäßigen numerischen Formatzeichenfolgen.

Systemsteuerungseinstellungen

Die Einstellungen im Element " Regions- und Sprachoptionen " in der Systemsteuerung beeinflussen die ergebniszeichenfolge, die von einem Formatierungsvorgang erzeugt wird. Diese Einstellungen werden verwendet, um das objekt zu initialisieren, das NumberFormatInfo der aktuellen Kultur zugeordnet ist, wodurch Werte bereitgestellt werden, die zum Steuern der Formatierung verwendet werden. Computer, die unterschiedliche Einstellungen verwenden, generieren unterschiedliche Ergebniszeichenfolgen.

Wenn der CultureInfo(String) Konstruktor verwendet wird, um ein neues CultureInfo Objekt zu instanziieren, das dieselbe Kultur wie die aktuelle Systemkultur darstellt, werden alle anpassungen, die vom Element " Regions- und Sprachoptionen " in der Systemsteuerung festgelegt wurden, 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 widerspiegelt.

NumberFormatInfo-Eigenschaften

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

Hinweis

Informationen zum Anpassen der Muster oder Zeichenfolgen, die bei der Formatierung numerischer Werte verwendet werden, finden Sie im NumberFormatInfo Klassenthema.

Integrale und Gleitkomma-Numerische Typen

Einige Beschreibungen von Standardmäßigen numerischen Formatbezeichnern beziehen sich auf integrale oder Gleitkomma-Numerische Typen. Die integralen numerischen Typen sind Byte, , SByte, Int16Int32, Int64, UInt16, UInt32, und UInt64BigInteger. Die numerischen Gleitkommatypen sind Decimal, Half, , Singleund Double.

Gleitkommainfinitäten und NaN

Unabhängig von der Formatzeichenfolge, wenn der Wert eines , oder Gleitkommatyps positive Unendlichkeit, negative Unendlichkeit oder keine Zahl (NaN) ist, ist die formatierte Zeichenfolge der Wert der entsprechenden Half, Singleoder Double Eigenschaft, die durch das aktuell anwendbare PositiveInfinitySymbol Objekt angegeben wird.NegativeInfinitySymbolNaNSymbolNumberFormatInfo

Codebeispiel

Im folgenden Beispiel wird ein integraler und ein Gleitkommawert mithilfe der en-US Kultur und aller standardmäßigen numerischen Formatbezeichner formatiert. In diesem Beispiel werden zwei bestimmte numerische Typen ( undDouble ) verwendet, würden jedoch ähnliche Ergebnisse für alle anderen numerischen Basistypen (Int32, Byte, , SByteInt16, Int32, , , Int64UInt16UInt32UInt64BigInteger, Decimalund Half) ergeben.Single

// 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: {floating.ToString("C", ci)}");           // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}");         // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}");         // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}");           // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}");         // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}");           // Displays "R: 10761.937554"
Console.WriteLine();

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

Siehe auch