Standardmäßige Zahlenformatzeichenfolgen

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

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

  • Die Genauigkeitsspezifikation ist eine optionale ganze Zahl, die sich auf die Anzahl der Ziffern in der resultierenden Zeichenfolge auswirkt. In .NET 7 und höher ist der maximale Genauigkeitswert 999.999.999.999. In .NET 6 ist Int32.MaxValueder maximale Genauigkeitswert . In früheren .NET-Versionen kann die Genauigkeit zwischen 0 und 99 liegen. Die Genauigkeitsangabe steuert die Anzahl der Ziffern in der Zeichenfolgendarstellung einer Zahl. Die Zahl selbst wird nicht gerundet. Verwenden Sie für einen Rundungsvorgang die Math.Ceiling-, Math.Floor- oder Math.Round-Methode.

    Wenn der Genauigkeitsspezifizierer die Anzahl von Dezimalstellen in der Ergebniszeichenfolge steuert, gibt die Ergebniszeichenfolge eine Zahl an, die auf ein darstellbares Ergebnis gerundet wird, das am ehesten dem unendlich präzisen Ergebnis entspricht. Wenn zwei gleich nahe darstellbare Ergebnisse vorhanden sind:

    • Im .NET Framework und in .NET Core bis .NET Core 2.0 wählt die Runtime das Ergebnis mit der größeren am wenigsten signifikanten Ziffer aus (d.h. MidpointRounding.AwayFromZero).
    • In .NET Core 2.1 und höher wählt die Runtime das Ergebnis mit einer geraden am wenigsten signifikanten Ziffer aus (d.h. MidpointRounding.ToEven).

    Hinweis

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

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

Tipp

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

Standardformatspezifizierer

Die folgenden Tabelle beschreibt die standardmäßigen Zahlenformatbezeichner und zeigt eine Beispielausgabe an, die von den einzelnen Formatbezeichnern erstellt wird. Weitere Informationen zur Verwendung von standardmäßigen numerischen Formatzeichenfolgen finden Sie im Abschnitt "Notizen " und im Codebeispiel für eine umfassende Abbildung ihrer Verwendung.

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

Formatbezeichner name BESCHREIBUNG Beispiele
"C" oder "c" Währung Ergebnis: Ein Währungswert

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: Anzahl der Dezimalstellen

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.CurrencyDecimalDigits definiert

Weitere Informationen finden Sie unter: Der Währungsformatspezifizierer „C“
123.456 ("C", en-US)
-> \$123.46

123.456 ("C", fr-FR)
-> 123,46 €

123.456 ("C", ja-JP)
-> ¥123

-123.456 ("C3", en-US)
-> (\$123.456)

-123.456 ("C3", fr-FR)
-> -123,456 €

-123.456 ("C3", ja-JP)
-> -¥123.456
"D" oder "d" Decimal Ergebnis: Ganzzahlige Ziffern mit optionalem Minuszeichen

Unterstützt von: ausschließlich integralen Typen

Genauigkeitsspezifizierer: Mindestanzahl von Ziffern

Standardgenauigkeitsspezifizierer: Mindestanzahl von erforderlichen Ziffern

Weitere Informationen finden Sie unter: Der Dezimalformatspezifizierer „D“
1234 ("D")
-> 1234

-1234 ("D6")
-> -001234
"E" oder "e" Exponential (wissenschaftlich) Ergebnis: Exponentialschreibweise

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: Anzahl der Dezimalstellen

Standardgenauigkeitsspezifizierer: 6.

Weitere Informationen finden Sie unter: Der Exponentialformatspezifizierer „E“
1052.0329112756 ("E", en-US)
-> 1.052033E+003

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

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

-1052.0329112756 ("E2", fr-FR)
-> -1,05E+003
"F" oder "f" Festkomma Ergebnis: Ganzzahlen und Dezimalzahlen mit optionalem Minuszeichen

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: Anzahl der Dezimalstellen

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiert

Weitere Informationen finden Sie unter: Der Festkommaformatspezifizierer „F“
1234.567 ("F", en-US)
-> 1234.57

1234.567 ("F", de-DE)
-> 1234,57

1234 ("F1", en-US)
-> 1234.0

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

-1234.56 ("F4", en-US)
-> -1234.5600

-1234.56 ("F4", de-DE)
-> -1234,5600
"G" oder "g" Allgemein Ergebnis: Die kompaktere Festkomma- oder wissenschaftliche Schreibweise.

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: Anzahl der signifikanten Ziffern.

Standardgenauigkeitsspezifizierer: abhängig vom numerischen Typ

Weitere Informationen finden Sie unter: Der allgemeine Formatspezifizierer „G“
-123.456 ("G", en-US)
-> -123.456

-123.456 ("G", sv-SE)
-> -123.456

123.4546 ("G4", en-US)
-> 123.5

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

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

-1.234567890e-25 ("G", sv-SE)
-> -1.23456789E-25
"N" oder "n" Anzahl Ergebnis: Ganzzahlen und Dezimalzahlen, Gruppentrennzeichen und ein Dezimaltrennzeichen mit optionalem Minuszeichen

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: gewünschte Anzahl der Dezimalstellen

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiert

Weitere Informationen finden Sie unter: Der numerische Formatspezifizierer „N“
1234.567 ("N", en-US)
-> 1.234.57

1234.567 ("N", ru-RU)
-> 1 234.57

1234 ("N1", en-US)
-> 1.234.0

1234 ("N1", ru-RU)
-> 1 234.0

-1234.56 ("N3", en-US)
-> -1,234.560

-1234.56 ("N3", ru-RU)
-> -1 234.560
"P" oder "p" Prozent Ergebnis: Die Zahl multipliziert mit 100 und mit einem Prozentzeichen versehen

Unterstützt von: allen numerischen Typen

Genauigkeitsspezifizierer: gewünschte Anzahl der Dezimalstellen

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.PercentDecimalDigits definiert

Weitere Informationen finden Sie unter: Der Prozentformatspezifizierer „P“
1 ("P", en-US)
-> 100,00 %

1 ("P", fr-FR)
-> 100,00 %

-0.39678 ("P1", en-US)
-> -39,7 %

-0.39678 ("P1", fr-FR)
-> -39,7 %
"R" oder "r" Schleife Ergebnis: Eine Zeichenfolge, die eine Schleife zu einem identischen Wert ausführen kann

Unterstützt von: Single, Double und BigInteger.

Hinweis: Wird ausschließlich für den Typ BigInteger empfohlen. Verwenden Sie für Double-Typen „G17“ und für Single-Typen „G9“.
Genauigkeitsspezifizierer: Ignoriert.

Weitere Informationen finden Sie unter: Der Roundtripformatspezifizierer „R“
123456789.12345678 ("R")
-> 123456789.12345678

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

Unterstützt von: ausschließlich integralen Typen

Genauigkeitsspezifizierer: Anzahl von Ziffern in der Ergebniszeichenfolge

Weitere Informationen: Der Hexadezimalwert ("X") Formatbezeichner.
255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Jedes andere einzelne Zeichen Unbekannter Bezeichner Ergebnis: Löst zur Laufzeit eine FormatException-Ausnahme aus.

Verwenden von standardmäßigen numerischen Formatzeichenfolgen

Hinweis

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

Eine 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 einen format Parameter enthält. Im folgenden Beispiel wird ein numerischer Wert in der aktuellen Kultur (in diesem Fall „en-US“) als Währungszeichenfolge formatiert.

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))
    ' Displays $123.46
    
  • Die Zeichenfolge kann als formatString-Argument in einem Formatelement angegeben werden, das beispielsweise mit den Methoden String.Format, Console.WriteLine und StringBuilder.AppendFormat verwendet wird. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung. Im folgenden Beispiel wird ein Währungswert mit einem Formatelement in eine Zeichenfolge eingefügt.

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

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

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16
    
    Dim amounts() As Decimal = {16305.32d, 18794.16d}
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Die Zeichenfolge kann als formatString-Argument in einem interpolierten Ausdruckselement einer interpolierten Zeichenfolge bereitgestellt werden. Weitere Informationen finden Sie im Artikel zur Zeichenfolgeninterpolation im C#-Verweis oder im Artikel " Interpolierte Zeichenfolgen " in der Visual Basic-Referenz.

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

Währungsformatspezifizierer (C)

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

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

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

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

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

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

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

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

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

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

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

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

Dezimalformatspezifizierer (D)

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

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

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

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

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

int value; 

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

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

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

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

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

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

Exponentieller Formatbezeichner (E)

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

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

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

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

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

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

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

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

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

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

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

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

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

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

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

Festkommaformatspezifizierer (F)

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

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

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

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

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

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

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

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

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

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

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

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

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

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

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

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

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

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

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

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

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

Allgemeiner Formatbezeichner (G)

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

Numerischer Typ Standardgenauigkeit
Byte oder SByte 3 Stellen
Int16 oder UInt16 5 Stellen
Int32 oder UInt32 10 Stellen
Int64 19 Stellen
UInt64 20 Stellen
BigInteger Unbegrenzt (identisch mit „R“)
Half 3 Stellen
Single 7 Stellen
Double 15 Stellen
Decimal 29 Stellen

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

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

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

Bei Verwendung mit einem Double Wert stellt der 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-konforme Gleitkommazahl (binary64) handelt, die bis zu 17 signifikante Genauigkeitsziffern aufgibt. Bei .NET Framework empfehlen wir die Verwendung anstelle des R-Formatspezifizierers, da in einigen Fällen "R" keine doppelgenauen Gleitkommawerte 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-konforme Gleitkommanummer (binary32) handelt, die bis zu neun signifikante Ziffern der Genauigkeit bietet. Aus Leistungsgründen wird empfohlen, dass dies der Verwendung des Formatbezeichners „R“ vorziehen.

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

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

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

double number;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Numerische Formatspezifikation (N)

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

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

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

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Zahlenformatbezeichner formatiert:

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

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

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

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

Prozentformatspezifizierer (P)

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

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

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

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Prozentformatbezeichner formatiert:

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

Round-Trip-Formatbezeichner (R)

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

In .NET Framework und in .NET Core-Versionen früher als 3.0 schlägt der "R"-Formatbezeichner in einigen Fällen keine erfolgreichen Roundtripwerte Double vor. DoubleSingle Für Werte bietet der Formatbezeichner "R" relativ schlechte Leistung. Stattdessen empfehlen wir zur erfolgreichen Durchführung von Roundtrips für Single-Werte, den Formatbezeichner „G17“ für Double-Werte und den Formatbezeichner „G9“ zu verwenden.

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

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

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

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

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

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


using System;
using System.Numerics;

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

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

Wichtig

In einigen Fällen werden Double-Werte, die mit der Standardformatzeichenfolge für Zahlen "R" formatiert sind, nicht erfolgreich zurückkonvertiert, wenn sie mit dem /platform:x64- oder dem /platform:anycpu-Parameter kompiliert wurden und auf 64-Bit-Systemen ausgeführt werden. Weitere Informationen erhalten Sie im folgenden Abschnitt.

Um das Problem der Double Werte zu umgehen, die mit der standardmäßigen numerischen Formatzeichenfolge "R" formatiert sind, können Double Sie werte mithilfe der /platform:x64/platform:anycpu 64-Bit-Systeme mit der Zeichenfolge "G17" formatieren, wenn sie mithilfe der standard numerischen Formatzeichenfolge "G17" kompiliert und ausgeführt werden. Im folgenden Beispiel wird die Formatzeichenfolge „R“ mit einem Double-Wert verwendet, der nicht erfolgreich zurückkonvertiert wird, und es wird die Formatzeichenfolge „G17“ verwendet, um erfolgreich in den ursprünglichen Wert zurückzukonvertieren:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Hexadezimalformat-Zeichner (X)

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

Die Genauigkeitsangabe gibt die gewünschte Mindestanzahl von Ziffern für die resultierende Zeichenfolge an. Bei Bedarf werden links von der Zahl Nullen ergänzt, um die durch die Genauigkeitsangabe bestimmte Anzahl von Ziffern zu erstellen.

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

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

int value; 

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

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

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

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

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

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

Hinweise

Dieser Abschnitt enthält zusätzliche Informationen zur Verwendung von standardmäßigen numerischen Formatzeichenfolgen.

Einstellungen der Systemsteuerung

Die Einstellungen der Regions- und Sprachoptionen in der Systemsteuerung beeinflussen die durch einen Formatierungsvorgang erstellte Ergebniszeichenfolge. Diese Einstellungen werden verwendet, um das NumberFormatInfo Objekt zu initialisieren, das der aktuellen Kultur zugeordnet ist, wodurch Werte bereitgestellt werden, die zum Steuern der Formatierung verwendet werden. Auf Computern mit anderen Einstellungen werden andere Ergebniszeichenfolgen generiert.

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

NumberFormatInfo-Eigenschaften

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

Hinweis

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

Ganzzahlige numerische Typen und numerische Gleitkommatypen

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

Unendlichkeiten und NaN bei Gleitkommawerten

Unabhängig von der Formatzeichenfolge, wenn der Wert eines Half, Singleoder Gleitkommatyps positive Unendlichkeit, negative Unendlichkeit oder Double keine Zahl (NaN) ist, ist die formatierte Zeichenfolge der Wert der jeweiligen PositiveInfinitySymbol, NegativeInfinitySymboloder NaNSymbol Eigenschaft, die von dem aktuell anwendbaren NumberFormatInfo Objekt angegeben wird.

Codebeispiel

Durch das folgende Beispiel werden mithilfe der Kultur en-US und allen Standardzahlen-Formatbezeichnern ein ganzzahliger Wert und ein numerischer Gleitkommawert formatiert. In diesem Beispiel werden zwei bestimmte numerische Typen (Double und ) verwendet, aber ähnliche Ergebnisse für alle anderen numerischen Basistypen (Byte, SByte, Int16Int64BigIntegerUInt64SingleInt32HalfUInt16DecimalUInt32usw. ) erhalten.Int32

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

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

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

Imports System.Globalization
Imports System.Threading

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

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

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

Siehe auch