Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
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:
Einige Überladungen der
ToString
Methode aller numerischen Typen. Sie können z. B. eine numerische Formatzeichenfolge für die Int32.ToString(String) und Int32.ToString(String, IFormatProvider) methoden angeben.Die
TryFormat
Methode aller numerischen Typen, z. B Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) . und Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).Das Zusammengesetztformatierungsfeature .NET, das von einigen
Write
MethodenWriteLine
ConsoleStreamWriter und Klassen, der String.Format Methode und der StringBuilder.AppendFormat Methode verwendet wird. Mit dem zusammengesetzten Formatfeature können Sie die Zeichenfolgendarstellung mehrerer Datenelemente in eine einzelne Zeichenfolge einschließen, die Feldbreite angeben und Zahlen in einem Feld ausrichten. Weitere Informationen finden Sie unter "Zusammengesetzte Formatierung".Interpolierte Zeichenfolgen in C# und Visual Basic, die eine vereinfachte Syntax im Vergleich zu zusammengesetzten Formatzeichenfolgen bereitstellen.
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, dieToString
über einenformat
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.
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 (binary32
Single-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.
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