Standardmäßige ZahlenformatzeichenfolgenStandard Numeric Format Strings

Standardformatzeichenfolgen für Zahlen werden für die Formatierung allgemeiner numerischer Typen verwendet.Standard numeric format strings are used to format common numeric types. Eine Standardformatzeichenfolge für Zahlen besitzt das Format Axx, wobei:A standard numeric format string takes the form Axx, where:

  • A ist ein einzelnes alphabetisches Zeichen, das als Formatbezeichner bezeichnet wird.A is a single alphabetic character called the format specifier. Jede Zahlenformatzeichenfolge, die mehr als ein alphabetisches Zeichen (einschließlich Leerzeichen) enthält, wird als benutzerdefinierte Zahlenformatzeichenfolge interpretiert.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Weitere Informationen finden Sie unter Benutzerdefinierte Zahlenformatzeichenfolgen.For more information, see Custom Numeric Format Strings.

  • xx ist eine optionale ganze Zahl, die als Genauigkeitsspezifizierer (Genauigkeitsangabe) bezeichnet wird.xx is an optional integer called the precision specifier. Die Genauigkeitsangabe reicht von 0 bis 99 und wirkt sich auf die Anzahl der Ziffern im Ergebnis aus.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Beachten Sie, dass die Genauigkeitsangabe die Anzahl der Ziffern in der Zeichenfolgendarstellung einer Zahl steuert.Note that the precision specifier controls the number of digits in the string representation of a number. Die Zahl selbst wird nicht gerundet.It does not round the number itself. Verwenden Sie für einen Rundungsvorgang die Math.Ceiling-, Math.Floor- oder Math.Round-Methode.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    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.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. Wenn zwei gleich nahe darstellbare Ergebnisse vorhanden sind:If there are two equally near representable results:

    • In .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).On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using 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).On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Hinweis

    Der Genauigkeitsspezifizierer bestimmt Anzahl von Ziffern in der Ergebniszeichenfolge.The precision specifier determines the number of digits in the result string. 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.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Standardmäßige Zahlenformatzeichenfolgen werden von Folgendem unterstützt:Standard numeric format strings are supported by:

Tipp

Sie können das Formatting Utilityherunterladen, eine Anwendung, mit der Sie Formatzeichenfolgen auf numerische Werte oder Datums- und Zeitwerte anwenden und die Ergebniszeichenfolge anzeigen können.You can download the Formatting Utility, an application that enables you to apply format strings to either numeric or date and time values and displays the result string.

Die folgenden Tabelle beschreibt die standardmäßigen Zahlenformatbezeichner und zeigt eine Beispielausgabe an, die von den einzelnen Formatbezeichnern erstellt wird.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Weitere Informationen über das Verwenden von standardmäßigen Zahlenformatzeichenfolgen finden Sie im Abschnitt Hinweise. Der Abschnitt Beispiel enthält eine umfassende Abbildung ihrer Verwendung.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

FormatbezeichnerFormat specifier nameName BeschreibungDescription BeispieleExamples
"C" oder "c""C" or "c" WährungCurrency Ergebnis: Ein WährungswertResult: A currency value.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: Anzahl der DezimalstellenPrecision specifier: Number of decimal digits.

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.CurrencyDecimalDigits definiertDefault precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Weitere Informationen: Der Währungsformatspezifizierer „C“More information: The Currency ("C") Format Specifier.
123.456 ("C", en-US) -> $123.46123.456 ("C", en-US) -> $123.46

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

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

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

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

-123.456 ("C3", ja-JP) -> -123,456 ¥-123.456 ("C3", ja-JP) -> -¥123.456
"D" oder "d""D" or "d" DecimalDecimal Ergebnis: Ganzzahlige Ziffern mit optionalem MinuszeichenResult: Integer digits with optional negative sign.

Unterstützt von: ausschließlich integralen TypenSupported by: Integral types only.

Genauigkeitsspezifizierer: Mindestanzahl von ZiffernPrecision specifier: Minimum number of digits.

Standardgenauigkeitsspezifizierer: Mindestanzahl von erforderlichen ZiffernDefault precision specifier: Minimum number of digits required.

Weitere Informationen: Der Dezimalformatspezifizierer „D“More information: The Decimal("D") Format Specifier.
1234 ("D") -> 12341234 ("D") -> 1234

-1234 ("D6") -> -001234-1234 ("D6") -> -001234
"E" oder "e""E" or "e" Exponential (wissenschaftlich)Exponential (scientific) Ergebnis: ExponentialschreibweiseResult: Exponential notation.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: Anzahl der DezimalstellenPrecision specifier: Number of decimal digits.

Standardgenauigkeitsspezifizierer: 6.Default precision specifier: 6.

Weitere Informationen: Der Exponentialformatspezifizierer „E“More information: The Exponential ("E") Format Specifier.
1052.0329112756 ("E", en-US) -> 1.052033E+0031052.0329112756 ("E", en-US) -> 1.052033E+003

1052.0329112756 ("e", fr-FR) -> 1,052033e+0031052.0329112756 ("e", fr-FR) -> 1,052033e+003

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

-1052.0329112756 ("E2", fr-FR) -> -1,05E+003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" oder "f""F" or "f" FestkommaFixed-point Ergebnis: Ganzzahlen und Dezimalzahlen mit optionalem MinuszeichenResult: Integral and decimal digits with optional negative sign.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: Anzahl der DezimalstellenPrecision specifier: Number of decimal digits.

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiertDefault precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Weitere Informationen: Der Festkommaformatspezifizierer „F“More information: The Fixed-Point ("F") Format Specifier.
1234.567 ("F", en-US) -> 1234.571234.567 ("F", en-US) -> 1234.57

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

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

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

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

-1234.56 ("F4", de-DE) -> -1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" oder "g""G" or "g" AllgemeinGeneral Ergebnis: Die kompaktere Festkomma- oder wissenschaftliche Schreibweise.Result: The more compact of either fixed-point or scientific notation.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: Anzahl der signifikanten Ziffern.Precision specifier: Number of significant digits.

Standardgenauigkeitsspezifizierer: abhängig vom numerischen TypDefault precision specifier: Depends on numeric type.

Weitere Informationen: Der allgemeine Formatspezifizierer „G“More information: The General ("G") Format Specifier.
-123.456 ("G", en-US) -> -123.456-123.456 ("G", en-US) -> -123.456

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

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

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

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

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" oder "n""N" or "n" AnzahlNumber Ergebnis: Ganzzahlen und Dezimalzahlen, Gruppentrennzeichen und ein Dezimaltrennzeichen mit optionalem MinuszeichenResult: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: gewünschte Anzahl der DezimalstellenPrecision specifier: Desired number of decimal places.

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.NumberDecimalDigits definiertDefault precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Weitere Informationen: Der numerische Formatspezifizierer „N“More information: The Numeric ("N") Format Specifier.
1234.567 ("N", en-US) -> 1,234.571234.567 ("N", en-US) -> 1,234.57

1234.567 ("N", ru-RU) -> 1 234,571234.567 ("N", ru-RU) -> 1 234,57

1234 ("N1", en-US) -> 1,234.01234 ("N1", en-US) -> 1,234.0

1234 ("N1", ru-RU) -> 1 234,01234 ("N1", ru-RU) -> 1 234,0

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

-1234.56 ("N3", ru-RU) -> -1 234,560-1234.56 ("N3", ru-RU) -> -1 234,560
"P" oder "p""P" or "p" ProzentPercent Ergebnis: Die Zahl multipliziert mit 100 und mit einem Prozentzeichen versehenResult: Number multiplied by 100 and displayed with a percent symbol.

Unterstützt von: allen numerischen TypenSupported by: All numeric types.

Genauigkeitsspezifizierer: gewünschte Anzahl der DezimalstellenPrecision specifier: Desired number of decimal places.

Standardgenauigkeitsspezifizierer: wird von NumberFormatInfo.PercentDecimalDigits definiertDefault precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Weitere Informationen: Der Prozentformatspezifizierer „P“More information: The Percent ("P") Format Specifier.
1 ("P", en-US) -> 100.00 %1 ("P", en-US) -> 100.00 %

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

-0.39678 ("P1", en-US) -> -39.7 %-0.39678 ("P1", en-US) -> -39.7 %

-0.39678 ("P1", fr-FR) -> -39,7 %-0.39678 ("P1", fr-FR) -> -39,7 %
"R" oder "r""R" or "r" SchleifeRound-trip Ergebnis: Eine Zeichenfolge, die eine Schleife zu einem identischen Wert ausführen kannResult: A string that can round-trip to an identical number.

Unterstützt von: Single, Double und BigInteger.Supported by: Single, Double, and BigInteger.

Hinweis: Wird ausschließlich für den Typ BigInteger empfohlen.Note: Recommended for the BigInteger type only. Verwenden Sie für Double-Typen „G17“ und für Single-Typen „G9“.For Double types, use "G17"; for Single types, use "G9".
Genauigkeitsspezifizierer: Ignoriert.Precision specifier: Ignored.

Weitere Informationen: Der Roundtripformatspezifizierer „R“More information: The Round-trip ("R") Format Specifier.
123456789.12345678 ("R") -> 123456789.12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567-1234567890.12345678 ("R") -> -1234567890.1234567
"X" oder "x""X" or "x" HexadezimalHexadecimal Ergebnis: Eine hexadezimale ZeichenfolgeResult: A hexadecimal string.

Unterstützt von: ausschließlich integralen TypenSupported by: Integral types only.

Genauigkeitsspezifizierer: Anzahl von Ziffern in der ErgebniszeichenfolgePrecision specifier: Number of digits in the result string.

Weitere Informationen: Der Hexadezimalformatspezifizierer „X“More information: The HexaDecimal ("X") Format Specifier.
255 ("X") -> FF255 ("X") -> FF

-1 ("x") -> ff-1 ("x") -> ff

255 ("x4") -> 00ff255 ("x4") -> 00ff

-1 ("X4") -> 00FF-1 ("X4") -> 00FF
Jedes andere einzelne ZeichenAny other single character Unbekannter BezeichnerUnknown specifier Ergebnis: Löst zur Laufzeit eine FormatException-Ausnahme aus.Result: Throws a FormatException at run time.

Verwenden von numerischen StandardformatzeichenfolgenUsing Standard Numeric Format Strings

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.The C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.Select the Run button to run an example in an interactive window. 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.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Eine numerische Standardformatzeichenfolge kann verwendet werden, um die Formatierung eines numerischen Werts wie folgt zu definieren:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Die Zeichenfolge kann an eine Überladung der ToString-Methode übergeben werden, die über einen format-Parameter verfügt.It can be passed to an overload of the ToString method that has a format parameter. Im folgenden Beispiel wird ein numerischer Wert in der aktuellen Kultur (in diesem Fall „en-US“) als Währungszeichenfolge formatiert.The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    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.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Weitere Informationen finden Sie unter Zusammengesetzte Formatierung.For more information, see Composite Formatting. Im folgenden Beispiel wird ein Währungswert mit einem Formatelement in eine Zeichenfolge eingefügt.The following example uses a format item to insert a currency value in a string.

    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.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. 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.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    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.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Weitere Informationen finden Sie im Artikel Zeichenfolgeninterpolation der C#-Referenz oder im Artikel Interpolierte Zeichenfolgen in der Visual Basic-Referenz.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

Die folgenden Abschnitte enthalten ausführliche Informationen zu den einzelnen numerischen Standardformatzeichenfolgen.The following sections provide detailed information about each of the standard numeric format strings.

Der Währungsformatbezeichner "C"The Currency ("C") Format Specifier

Mit dem Währungsformatbezeichner "C" wird eine Zahl in eine Zeichenfolge konvertiert, die einen Währungswert darstellt.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen in der Ergebniszeichenfolge an.The precision specifier indicates the desired number of decimal places in the result string. Wenn die Genauigkeitsangabe fehlt, wird die Standardgenauigkeit von der NumberFormatInfo.CurrencyDecimalDigits-Eigenschaft definiert.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

Wenn der zu formatierende Wert mehr als die angegebene oder die standardmäßige Anzahl von Dezimalstellen aufweist, wird der Bruchwert in der Ergebniszeichenfolge gerundet.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. 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.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabelle sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der zurückgegebenen Zeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
CurrencyPositivePattern Definiert die Platzierung des Währungssymbols für positive Werte.Defines the placement of the currency symbol for positive values.
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.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Definiert das verwendete Minuszeichen, wenn CurrencyNegativePattern angibt, dass keine Klammern verwendet werden.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Definiert das Währungssymbol.Defines the currency symbol.
CurrencyDecimalDigits Definiert die Standardanzahl von Dezimalstellen in einem Währungswert.Defines the default number of decimal digits in a currency value. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Definiert die Anzahl von ganzzahligen Ziffern, die in einer Gruppe angezeigt werden.Defines the number of integer digits that appear in a group.

Im folgenden Beispiel wird ein Double-Wert mit dem Währungsformatbezeichner formatiert.The following example formats a Double value with the currency format specifier.

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

Zurück zur TabelleBack to table

Der Dezimalformatbezeichner "D"The Decimal ("D") Format Specifier

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.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Dieses Format wird nur bei ganzzahligen Typen unterstützt.This format is supported only for integral types.

Die Genauigkeitsangabe gibt die gewünschte Mindestanzahl von Ziffern für die resultierende Zeichenfolge an.The precision specifier indicates the minimum number of digits desired in the resulting string. Bei Bedarf werden links von der Zahl Nullen ergänzt, um die durch die Genauigkeitsangabe bestimmte Anzahl von Ziffern zu erstellen.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Bei fehlender Genauigkeitsangabe wird standardmäßig der zur Darstellung der ganzen Zahl ohne führende Nullen erforderliche Minimalwert zugrunde gelegt.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. Wie die folgende Tabelle zeigt, wirkt sich eine einzelne Eigenschaft auf die Formatierung der Ergebniszeichenfolge aus.As the following table shows, a single property affects the formatting of the result string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.

Im folgenden Beispiel wird ein Int32-Wert mit dem Dezimalformatbezeichner formatiert.The following example formats an Int32 value with the decimal format specifier.

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

Zurück zur TabelleBack to table

Der Exponentialformatbezeichner "E"The Exponential ("E") Format Specifier

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).The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist.The string starts with a minus sign if the number is negative. Es steht immer genau eine Ziffer vor dem Dezimaltrennzeichen.Exactly one digit always precedes the decimal point.

Die Genauigkeitsangabe gibt die gewünschte Anzahl von Ziffern nach dem Dezimaltrennzeichen an.The precision specifier indicates the desired number of digits after the decimal point. Wenn die Genauigkeitsangabe fehlt, werden als Standard sechs Ziffern nach dem Dezimaltrennzeichen angegeben.If the precision specifier is omitted, a default of six digits after the decimal point is used.

Die Groß- oder Kleinschreibung des Formatbezeichners gibt an, ob dem Exponenten ein "E" oder ein "e" vorangestellt wird.The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". Der Exponent besteht immer aus einem Plus- oder Minuszeichen und mindestens drei Ziffern.The exponent always consists of a plus or minus sign and a minimum of three digits. Der Exponent wird ggf. durch Nullen ergänzt, um diesem Mindestwert zu entsprechen.The exponent is padded with zeros to meet this minimum, if required.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabelle sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der zurückgegebenen Zeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl sowohl für den Koeffizienten als auch für den Exponenten negativ ist.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Definiert die Zeichenfolge, die die ganzzahlige Ziffer von Dezimalstellen im Koeffizienten trennt.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.Defines the string that indicates that an exponent is positive.

Im folgenden Beispiel wird ein Double-Wert mit dem Exponentialformatbezeichner formatiert.The following example formats a Double value with the exponential format specifier.

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

Zurück zur TabelleBack to table

Der Festkommaformatbezeichner "F"The Fixed-Point ("F") Format Specifier

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).The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist.The string starts with a minus sign if the number is negative.

Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen an.The precision specifier indicates the desired number of decimal places. Bei fehlender Genauigkeitsangabe wird die numerische Genauigkeit von der NumberFormatInfo.NumberDecimalDigits-Eigenschaft angegeben.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabelle sind die Eigenschaften des NumberFormatInfo-Objekts aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Definiert die Standardanzahl von Dezimalzahlen.Defines the default number of decimal digits. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.This value can be overridden by using the precision specifier.

Im folgenden Beispiel wird ein Double-Wert und ein Int32-Wert mit dem Festkommaformatbezeichner formatiert.The following example formats a Double and an Int32 value with the fixed-point format specifier.

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                        

Zurück zur TabelleBack to table

Der allgemeine Formatbezeichner "G"The General ("G") Format Specifier

Der allgemeine Formatbezeichner „G“ konvertiert eine Zahl abhängig von ihrem Typ und dem Vorhandensein eines Genauigkeitsspezifizierer in die kompaktere Festkomma- oder wissenschaftliche Schreibweise.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. Die Genauigkeitsangabe definiert die maximale Anzahl von signifikanten Stellen, die in der Ergebniszeichenfolge angezeigt werden können.The precision specifier defines the maximum number of significant digits that can appear in the result string. Wenn die Genauigkeitsangabe fehlt oder 0 (null) ist, wird die Standardgenauigkeit über den Typ der Zahl festgelegt (siehe folgende Tabelle).If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Numerischer TypNumeric type StandardgenauigkeitDefault precision
Byte oder SByteByte or SByte 3 Stellen3 digits
Int16 oder UInt16Int16 or UInt16 5 Stellen5 digits
Int32 oder UInt32Int32 or UInt32 10 Stellen10 digits
Int64 19 Stellen19 digits
UInt64 20 Stellen20 digits
BigInteger Unbegrenzt (identisch mit „R“)Unlimited (same as "R")
Single 7 Stellen7 digits
Double 15 Stellen15 digits
Decimal 29 Stellen29 digits

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.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. Das Ergebnis enthält ggf. ein Dezimaltrennzeichen. Nachfolgende Nullen nach dem Dezimaltrennzeichen werden weggelassen.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. 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.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

Wenn die Zahl jedoch eine Decimal ist und kein Genauigkeitsspezifizierer angegeben wurde, wird die Festkommanotation in jedem Fall verwendet und nachfolgende Nullen bleiben erhalten.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

Bei Verwendung der wissenschaftlichen Notation wird dem Exponenten im Ergebnis "E" vorangestellt, wenn der Formatbezeichner "G" ist, oder "e", wenn der Formatbezeichner "g" ist.If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". Der Exponent enthält mindestens zwei Ziffern.The exponent contains a minimum of two digits. Dies stellt einen Unterschied zum wissenschaftlichen Notationsformat dar, das vom exponentiellen Formatbezeichner erzeugt wird und mindestens drei Ziffern im Exponenten verwendet.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Beachten Sie, dass der Formatbezeichner „G17“ bei Verwendung mit einem Double-Wert sicherstellt, dass der ursprüngliche Double-Wert erfolgreich Roundtrips ausführt.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Grund hierfür ist, dass es sich bei Double um eine mit IEEE 754-2008 konformer Gleitkommazahl mit doppelter Genauigkeit (binary64) handelt, die bis zu 17 gültige Stellen aufweist.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Es wird empfohlen, diesen anstelle des Formatbezeichners „R“ zu verwenden, da „R“ in einigen Fällen keine Roundtrips für Gleitkommawerte mit doppelter Genauigkeit durchführen kann.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. Einer dieser Fälle wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates one such case.

double original = 0.84551240822557006;
var rSpecifier = original.ToString("R");
var g17Specifier = original.ToString("G17");

var rValue = Double.Parse(rSpecifier);
var g17Value = Double.Parse(g17Specifier);

Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

Bei Verwendung mit einem Single-Wert stellt der Formatbezeichner „G9“ sicher, dass der ursprüngliche Single-Wert erfolgreich Roundtrips durchführt.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Grund hierfür ist, dass es sich bei Single um eine mit IEEE 754-2008 konformer Gleitkommazahl mit einfacher Genauigkeit (binary32) handelt, die bis zu neun gültige Stellen aufweist.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Aus Leistungsgründen wird empfohlen, dass dies der Verwendung des Formatbezeichners „R“ vorziehen.For performance reasons, we recommend its use instead of the "R" format specifier.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabellen sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.Defines the string that separates integral digits from decimal digits.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.Defines the string that indicates that an exponent is positive.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem allgemeinen Formatbezeichner formatiert.The following example formats assorted floating-point values with the general format specifier.

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    

Zurück zur TabelleBack to table

Der numerische Formatbezeichner "N"The Numeric ("N") Format Specifier

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.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Ziffern nach dem Dezimaltrennzeichen an.The precision specifier indicates the desired number of digits after the decimal point. Bei fehlender Genauigkeitsangabe wird die Anzahl der Dezimalstellen von der aktuellen NumberFormatInfo.NumberDecimalDigits-Eigenschaft definiert.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabellen sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.
NumberNegativePattern Definiert das Format von negativen Werten und gibt an, ob das Minuszeichen durch Klammern oder durch die NegativeSign-Eigenschaft dargestellt wird.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Definiert die Anzahl von ganzzahligen Ziffern, die zwischen Gruppentrennzeichen angezeigt werden.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Definiert die Standardanzahl von Dezimalzahlen.Defines the default number of decimal digits. Dieser Wert kann mit einer Genauigkeitsangabe überschrieben werden.This value can be overridden by using a precision specifier.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Zahlenformatbezeichner formatiert.The following example formats assorted floating-point values with the number format specifier.

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 

Zurück zur TabelleBack to table

Der Prozentformatbezeichner "P"The Percent ("P") Format Specifier

Der Prozentformatbezeichner "P" multipliziert eine Zahl mit 100 und konvertiert sie in eine Zeichenfolge, die einen Prozentsatz darstellt.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. Die Genauigkeitsangabe gibt die gewünschte Anzahl von Dezimalstellen an.The precision specifier indicates the desired number of decimal places. Bei fehlender Genauigkeitsangabe wird die Standardgenauigkeit für Zahlen verwendet, die von der aktuellen PercentDecimalDigits-Eigenschaft angegeben wird.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

In der folgenden Tabelle sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der zurückgegebenen Zeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
PercentPositivePattern Definiert die Platzierung des Prozentsymbols für positive Werte.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Definiert die Platzierung des Prozentsymbols sowie des Minuszeichens für negative Werte.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.
PercentSymbol Definiert das Prozentsymbol.Defines the percent symbol.
PercentDecimalDigits Definiert die Standardanzahl von Dezimalstellen in einem Prozentwert.Defines the default number of decimal digits in a percentage value. Dieser Wert kann mit der Genauigkeitsangabe überschrieben werden.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen und Dezimalzahlen trennt.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Definiert die Zeichenfolge, die Gruppen von ganzen Zahlen trennt.Defines the string that separates groups of integral numbers.
PercentGroupSizes Definiert die Anzahl von ganzzahligen Ziffern, die in einer Gruppe angezeigt werden.Defines the number of integer digits that appear in a group.

Im folgenden Beispiel werden gemischte Gleitkommawerte mit dem Prozentformatbezeichner formatiert.The following example formats floating-point values with the percent format specifier.

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 %

Zurück zur TabelleBack to table

Der Schleifenformatbezeichner "R"The Round-trip ("R") Format Specifier

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.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Dieses Format wird nur für folgende Typen unterstützt: Single, Double und BigInteger.This format is supported only for the Single, Double, and BigInteger types.

Bei Double-Werten kann der Formatbezeichner „R“ in einigen Fällen keinen Roundtrip für den ursprünglichen Wert durchführen.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. Für die Werte Double und Single bietet er auch eine relativ schlechte Leistung.For both Double and Single values, it also offers relatively poor performance. 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.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Wenn ein BigInteger-Wert mit diesem Bezeichner formatiert wird, enthält seine Zeichenfolgendarstellung alle signifikanten Stellen im BigInteger-Wert.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Eine Genauigkeitsangabe kann zwar vorhanden sein, sie wird jedoch ignoriert.Although you can include a precision specifier, it is ignored. Bei diesem Bezeichner hat die Rückkonvertierbarkeit höhere Priorität als die Genauigkeit.Round trips are given precedence over precision when using this specifier.
Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts beeinflusst.The result string is affected by the formatting information of the current NumberFormatInfo object. In der folgenden Tabellen sind die NumberFormatInfo-Eigenschaften aufgeführt, die die Formatierung der Ergebniszeichenfolge steuern.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

NumberFormatInfo-EigenschaftNumberFormatInfo property BeschreibungDescription
NegativeSign Definiert die Zeichenfolge, die angibt, dass eine Zahl negativ ist.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definiert die Zeichenfolge, die ganze Zahlen von Dezimalzahlen trennt.Defines the string that separates integral digits from decimal digits.
PositiveSign Definiert die Zeichenfolge, die angibt, dass ein Exponent positiv ist.Defines the string that indicates that an exponent is positive.

Im folgenden Beispiel wird ein BigInteger-Wert mit dem Roundtripformatbezeichner formatiert.The following example formats a BigInteger value with the round-trip format specifier.

#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.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Weitere Informationen erhalten Sie im folgenden Abschnitt.See the following paragraph for more information.

Um das Problem zu umgehen, dass mit der standardmäßigen numerischen Formatierungszeichenfolge "R" formatierte Double-Werte bei der Kompilierung mit der /platform:x64-Option oder der /platform:anycpu-Option und bei Ausführung auf 64-Bit-Systemen keinen erfolgreichen Roundtrip durchführen, können Sie Double-Werte mit der standardmäßigen numerischen Formatierungszeichenfolge "G17" formatieren.To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. Im folgenden Beispiel wird die Formatzeichenfolge "R" mit einem Double-Wert verwendet, der nicht erfolgreich zurückkonvertiert wird, und es wird die Formatzeichenfolge "G17" verwendet, um erfolgreich in den ursprünglichen Wert zurückzukonvertieren.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

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

Zurück zur TabelleBack to table

Der Hexadezimal-Formatbezeichner "X"The Hexadecimal ("X") Format Specifier

Der Hexadezimal-Formatbezeichner "X" konvertiert eine Zahl in eine Zeichenfolge von Hexadezimalzahlen.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. Die Schreibweise des Formatbezeichners gibt an, ob Groß- oder Kleinbuchstaben für Hexadezimalzahlen verwendet werden sollen, die größer als 9 sind.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Verwenden Sie z. B. "X" für "ABCDEF", und "x" für "abcdef".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Dieses Format wird nur bei ganzzahligen Typen unterstützt.This format is supported only for integral types.

Die Genauigkeitsangabe gibt die gewünschte Mindestanzahl von Ziffern für die resultierende Zeichenfolge an.The precision specifier indicates the minimum number of digits desired in the resulting string. Bei Bedarf werden links von der Zahl Nullen ergänzt, um die durch die Genauigkeitsangabe bestimmte Anzahl von Ziffern zu erstellen.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

Die Ergebniszeichenfolge wird von den Formatierungsinformationen des aktuellen NumberFormatInfo-Objekts nicht beeinflusst.The result string is not affected by the formatting information of the current NumberFormatInfo object.

Im folgenden Beispiel wird Int32-Werte mit dem Hexadezimal-Formatbezeichner formatiert.The following example formats Int32 values with the hexadecimal format specifier.

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

Zurück zur TabelleBack to table

HinweiseNotes

Einstellungen der SystemsteuerungControl Panel Settings

Die Einstellungen der Regions- und Sprachoptionen in der Systemsteuerung beeinflussen die durch einen Formatierungsvorgang erstellte Ergebniszeichenfolge.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Mithilfe dieser Einstellungen wird das NumberFormatInfo-Objekt initialisiert, das der aktuellen Threadkultur zugeordnet ist. Sie stellt Werte zur Steuerung der Formatierung bereit.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Auf Computern mit anderen Einstellungen werden andere Ergebniszeichenfolgen generiert.Computers that use different settings generate different result strings.

Wenn der CultureInfo.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.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. Sie können den CultureInfo.CultureInfo(String, Boolean) -Konstruktor verwenden, um ein CultureInfo -Objekt zu erstellen, das die Anpassungen eines Systems nicht wiedergibt.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

NumberFormatInfo-EigenschaftenNumberFormatInfo Properties

Die Formatierung wird durch die Eigenschaften des aktuellen NumberFormatInfo-Objekts beeinflusst, das implizit durch die aktuelle Threadkultur oder explizit durch den IFormatProvider-Parameter der Methode bereitgestellt wird, die die Formatierung aufruft.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Geben Sie ein NumberFormatInfo-Objekt oder ein CultureInfo-Objekt für diesen Parameter an.Specify a NumberFormatInfo or CultureInfo object for that parameter.

Hinweis

Informationen zum Anpassen der Muster oder Zeichenfolgen, die beim Formatieren der numerischer Werte verwendet werden, finden Sie im Thema zur NumberFormatInfo-Klasse.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Ganzzahlige numerische Typen und numerische GleitkommatypenIntegral and Floating-Point Numeric Types

Einige Beschreibungen standardmäßiger Zahlenformatbezeichner verweisen auf ganzzahlige numerische Typen oder numerische Gleitkommatypen.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Die ganzzahligen numerischen Typen sind Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 und BigInteger.The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Die numerischen Gleitkommatypen sind Decimal, Single und Double.The floating-point numeric types are Decimal, Single, and Double.

Unendlichkeiten und NaN bei GleitkommawertenFloating-Point Infinities and NaN

Wenn der Wert eines Single-Gleitkommatyps oder eines Double-Gleitkommatyps positiv unendlich, negativ unendlich oder keine Zahl (Not a Number, NaN) ist, handelt es sich bei der formatierten Zeichenfolge unabhängig von der Formatzeichenfolge um den Wert der entsprechenden PositiveInfinitySymbol-Eigenschaft, NegativeInfinitySymbol-Eigenschaft oder NaNSymbol-Eigenschaft, die durch das derzeit gültige NumberFormatInfo-Objekt angegeben wird.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

BeispielExample

Hinweis

Einige der C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.Select the Run button to run an example in an interactive window. 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.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Durch das folgende Beispiel werden mithilfe der Kultur en-US und allen Standardzahlen-Formatbezeichnern ein ganzzahliger Wert und ein numerischer Gleitkommawert formatiert.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. In diesem Beispiel werden zwei bestimmte numerische Typen (Double und Int32) verwendet. Die Ergebnisse sind jedoch für alle numerischen Basistypen (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal und Single) ähnlich.This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and 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: {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 auchSee also