Standard numeric format parsing precision

.NET now supports greater precision values when formatting numbers as strings using ToString and TryFormat.

When formatting numbers as strings, the precision specifier in the format string represents the number of digits in the resulting string. Depending on the format specifier, which is the character at the beginning of the string, the precision can represent the total number of digits, the number of significant digits, or the number of decimal digits.

In previous .NET versions, the standard numeric format parsing logic is limited to a precision of 99 or less. Some numeric types have more precision, but ToString(string format) does not expose it correctly. If you specify a precision greater than 99, for example, 32.ToString("C100"), the format string is interpreted as a custom numeric format string instead of "currency with precision 100". In custom numeric format strings, characters are interpreted as character literals. In addition, a format string that contains an invalid format specifier is interpreted differently depending on the precision value. H99 throws a FormatException for the invalid format specifier, while H100 is interpreted as a custom numeric format string.

Starting in .NET 6, .NET supports precision up to Int32.MaxValue. A format string that consists of a format specifier with any number of digits is interpreted as a standard numeric format string with precision. A FormatException is thrown for either or both of the following conditions:

• The format specifier character is not a standard format specifier.
• The precision is greater than Int32.MaxValue.

This change was implemented in the parsing logic that affects all numeric types.

The following table shows the behavior changes for various format strings.

.NET 6

This change corrects unexpected behavior when using higher precision for numeric format parsing.

In most cases, no action is necessary and the correct precision will be shown in the resulting strings.

However, if you want to revert to the previous behavior where the format specifier is interpreted as a literal character when the precision is greater than 99, you can wrap that character in single quotes or escape it with a backslash. For example, in previous .NET versions, 42.ToString("G999") returns G999. To maintain that behavior, change the format string to "'G'999" or "\\G999". This will work on .NET Framework, .NET Core, and .NET 5+.

The following format strings will continue to be interpreted as custom numeric format strings:

• Start with any character that is not an ASCII alphabetical character, for example, $ or è.
• Start with an ASCII alphabetical character that's not followed by an ASCII digit, for example, A$.
• Start with an ASCII alphabetical character, followed by an ASCII digit sequence, and then any character that is not an ASCII digit character, for example, A12A.

This change was implemented in the parsing logic that affects all numeric types.

• System.Numerics.BigInteger.ToString(String)
• System.Numerics.BigInteger.ToString(String, IFormatProvider)
• System.Numerics.BigInteger.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Int32.ToString(String)
• System.Int32.ToString(String, IFormatProvider)
• System.Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.UInt32.ToString(String)
• System.UInt32.ToString(String, IFormatProvider)
• System.UInt32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Byte.ToString(String)
• System.Byte.ToString(String, IFormatProvider)
• System.Byte.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.SByte.ToString(String)
• System.SByte.ToString(String, IFormatProvider)
• System.SByte.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Int16.ToString(String)
• System.Int16.ToString(String, IFormatProvider)
• System.Int16.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.UInt16.ToString(String)
• System.UInt16.ToString(String, IFormatProvider)
• System.UInt16.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Int64.ToString(String)
• System.Int64.ToString(String, IFormatProvider)
• System.Int64.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.UInt64.ToString(String)
• System.UInt64.ToString(String, IFormatProvider)
• System.UInt64.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Half.ToString(String)
• System.Half.ToString(String, IFormatProvider)
• System.Half.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Single.ToString(String)
• System.Single.ToString(String, IFormatProvider)
• System.Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Double.ToString(String)
• System.Double.ToString(String, IFormatProvider)
• System.Double.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
• System.Decimal.ToString(String)
• System.Decimal.ToString(String, IFormatProvider)
• System.Decimal.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

• Standard numeric format strings
• Character literals in custom format strings
• Maximum precision for numeric format strings (.NET 7)