ToString("0") versus ToString(CultureInfo.InvariantCulture)

Question

I would like to make sure that certain numbers in my application are printed without any separators, groupings etc. no matter what the current environment is. It seems that the following two methods produce the same results (there are possibly more):

123456789.ToString("0");
123456789.ToString(CultureInfo.InvariantCulture);

Are you aware of any edge cases or quirks? Which one is more "correct"? Which one would you use?

I used to use the second one, but recently I found the first one and started using it because it does not require the additional using System.Globalization.

Heave

Answer 1

Based on the answers and the discussion here, I did some more investigation. Here is what I found:

• When you use 12345678.ToString() without any arguments, .NET uses general the general format specifier "G" which is affected only by NumberFormatInfo.NegativeSign, NumberFormatInfo. NumberDecimalSeparator, NumberFormatInfo.NumberDecimalDigits and NumberFormatInfo.PositiveSign. To me this says that in any culture 12345678.ToString() should always produce "12345678".

• If you want to separate digits, you need to use the numeric format specifier "N" (or, of course, to provide a custom format string). The digit grouping also applies to "C" and "P".

• The invariant culture does indeed specify digit grouping (by 3 digits, of course) and a digit separator. So the reason that 123456789.ToString(CultureInfo.InvariantCulture) produces "123456789" is not because of the invariant culture, but it’s because of the default general numeric format specifier "G".

So I would say that the conclusion is that it’s perfectly OK not to worry about any extra arguments and just use:

12345678.ToString()

I think that this the best from all cases because it means that usually you don’t need to even call ToString() because most of the print/write functions accept all sorts of arguments and do the ToString() for you.

Heave

Answer 2

The two methods are not equivalent: the first is using the CurrentCulture. This could lead to extra dots/commas in certain cultures (I don't have examples).

When you use InvariantCulture you are certain that always the same formatting is used.

Edit: And, if you use CodeAnalysis, that will complain when you don't use a CultureInfo.

Sty

I tested the first one by modifying the current thread culture, and it did not affect it. I think the "0" means: at least one digit + no digit grouping or separators. If I wanted to have some digit grouping or separators, I think I would have to do something like "000,000". – Heave

But you are right: InvariantCulture "sounds" more explicit. Even MSDN says "... it is associated with the English language but not with any country/region". Hmm, when I think about more, ToString(CultureInfo.InvariantCulture), it means that the number if formatted using the "G". It all just happens to work ONLY because "G" does not seem to be using any grouping. BUT (I just looked it up) the invariant culture has some grouping specified. For instance, try 12345789.ToString("N", CultureInfo.InvariantCulture). – Heave

Answer 3

The .ToString() and .ToString(CultureInfo.InvariantCulture) seems give the same result for integers.

The code below gives "809 cultures tested, 0 differences found" result on my PC (for .NET Framework 4.7.2):

var cultures = CultureInfo.GetCultures(CultureTypes.AllCultures).ToArray();
var numbers = new[] { 0, -1, 1, int.MinValue, int.MaxValue };

var diffsFound = 0;
foreach (var culture in cultures)
{
    foreach (var number in numbers)
    {
        var s1 = number.ToString();
        var s2 = number.ToString(culture);
        if (s1 != s2)
        {
            Console.WriteLine($"{culture.DisplayName}: {s1} != {s2}");
            diffsFound++;
        }
    }
}

Console.WriteLine($"{cultures.Length} cultures tested, {diffsFound} differences found.");

Retrogression

When I run this code on DotNetFiddle, I get 178 differences found, using .NET Core 3.1: dotnetfiddle.net/ta2jvd 733 cultures tested, 178 differences found.FZF – Skirret

Answer 4

(~5 years later...)

I was looking up this exact question, but since there was no accepted answer and even though Jan Zich is correct I thought I would put together a little example to test this.

I would also go so far to say that there is no difference between .ToString(), .ToString("0"), and .ToString(Any Culture Info) (as far as integers and decimals are concerned)

var cultures = CultureInfo.GetCultures(CultureTypes.AllCultures)
    .Except(CultureInfo.GetCultures(CultureTypes.SpecificCultures));

foreach(var c in cultures){
    var num = (int.MinValue);/*
    var num = (int.MaxValue);/*
    var num = (decimal.MinValue);/*
    var num = (decimal.MaxValue);/*
--*/

    var s1 = num.ToString("0") ;
    var s2 = num.ToString(c);
    if(s1 != s2){
        var s = string.Format("{2}:  {0}    {1}",s1,s2,c);
        s.Dump();
    }
}

LinqPad snippet

Pacheco

Answer 5

As I see it, The first one will format is a number with at least one character using the default culture of the computer. The second will format it as a number depending on the InvariantCulture rules.

Bobby

Stairwell

Correct me if I’m wrong: I thought that no digit grouping, separator etc. apply to 123456789.ToString("0")? – Heave

Uhhh...it really doesn't. I've mistaken it for a formatting symbol like "N0", which does apply the current culture rules. You're right, since the 0 is a direct formatting it doesn't apply any culture information. Though, someone could also use 123456789.ToString(); . – Stairwell

Answer 6

2 lines do different things. The first line formats the number with the local culture and the second one converts it to string without formatting but using CultureInfo.InvariantCulture.

You use CultureInfo.InvariantCulture with this kind of methods (ToString, ToLower ...) to make sure that when the value is used by any software (database, another library ...), no matter what their culture is, it will result the same value and when they can pick up this value, they can continue processing it. However if you don't use this the other software has to figure out what your culture is. Did you mean decimal separator with comma or something else ... ?

All and all use CultureInfo.InvariantCulture when you want to exchange/use values among libraries, databases and use CultureInfo.CurrentCulture to show to the users of your application.

// for softwares
string mystring1 = 1234.ToString("0", CultureInfo.InvariantCulture);

// for your application users
string mystring2 = 1234.ToString("0", CultureInfo.CurrentCulture);

Impetrate

Answer 7

If you're wanting to make sure to specify "no formatting, no matter what" I personally think the first option you have:

123456789.ToString("0");

better communicates the intent. The downside would be if a culture overrode the format string of "0" for the numeric type you are using.

Pachston

Oh, I did now know that you can override the format strings? I need to look it up. – Heave

Are you sure about the overloading? MSDN (msdn.microsoft.com/en-us/library/dwhawy9k.aspx) says: "Any other single character [than one of those standard] throws a FormatException at run time." – Heave

I was not sure if this was the case or not. I see a quick trip to the MSDN library would have shown me :). – Pachston