Cross-regional decimal/double parsing

Question

As a matter of fact, I have multiple systems that can generate numeric data and they are stored on some web server in text files. Some of the systems use decimal point as fraction separator, some of the systems use decimal comma as same.

Applications (fat client, .net 2.0) can also be run on either kind of systems.

So after some stumbling I did this: ( http://pastebin.com/vhLXABDD )

    public static bool HasDecimalComma;
    public static bool HasDecimalPeriod;

    public static double GetNumber(string NumberString)
    {
        if (!HasDecimalComma && !HasDecimalPeriod)
        {
            string s = string.Format("{0:0.0}", 123.123);
            if (s.Contains('.'))
            {
                HasDecimalPeriod = true;
            }
            else if (s.Contains(','))
            {
                HasDecimalComma = true;
            }
            else
            {
                throw new SystemException(string.Format("strange number format '{0}'", s));
            }
        }
        if (HasDecimalComma)
        {
            return double.Parse(NumberString.Replace('.', ','));
        }
        if (HasDecimalPeriod)
        {
            return double.Parse(NumberString.Replace(',', '.'));
        }
        throw new ArgumentException(string.Format("can't parse '{0}'", NumberString));
    }

Would you suggest any better, more elegant way?

EDIT:

I am sorry for not mentioning it before, and since your answers lean in that direction - I can't store generating culture with the numbers, I can only try to 'detect' it.

Can you store the generating culture with the number string? That would alleviate any need for such string-bending. — SWeko, Sep 02 '13 at 11:01
DO you know roughly what the generated numbers will be? eg down to a set of options? I'm not sure how your system would deal with parsing "1,000.12" (actually I do know, it would break). If you have a limited number of possible formats then you could just try each of them if they have no possibility of ambiguity. — Chris, Sep 02 '13 at 11:19
I have that luck so no thousands separator will be present EVER. — Daniel Mošmondor, Sep 02 '13 at 11:20
So you can guarantee that your number is a string of digits with a possible leading minus sign and either a ".", a "," or neither somewhere in the string? — Chris, Sep 02 '13 at 11:23
Always, always, always serialise floating points using the invariant culture. Persisted date should always be in a known form. If it is not, you have failed. http://msdn.microsoft.com/en-us/library/system.globalization.cultureinfo.invariantculture.aspx — Gusdor, Sep 02 '13 at 12:10

score 3 · Answer 1 · answered Sep 02 '13 at 11:19

3

Try with this:

    static double GetDouble(string s)
    {
        double d;

        var formatinfo = new NumberFormatInfo();

        formatinfo.NumberDecimalSeparator = ".";

        if (double.TryParse(s, NumberStyles.Float, formatinfo, out d))
        {
            return d;
        }

        formatinfo.NumberDecimalSeparator = ",";

        if (double.TryParse(s, NumberStyles.Float, formatinfo, out d))
        {
            return d;
        }

        throw new SystemException(string.Format("strange number format '{0}'", s));
    }

answered Sep 02 '13 at 11:19

Alessandro D'Andria

8,663
2
36
32

This may not work in the case of `.` being used as a thousand separator. – Chris Sep 02 '13 at 11:21
1

Apparently not a problem as has been clarified in comments (to the question) so this looks good. – Chris Sep 02 '13 at 11:24

SWeko · Answer 2 · 2013-09-02T11:50:48.660

If you are unable to change the call site, and you guarantee that no other kind of separator will be present beside the decimal separator, then you can, more or less use your method. I would suggest

Мoving the HasDecimalComma and HasDecimalPeriod to the body of the method - global state is absolutely not necessary in this case.
Using TryParse instead of Parse, because the numbers are expected to be potentially faulty.
Explitly specifying the InvariantCulture culture (it has a decimal period).
Allowing for number that have neither comma nor period, since "3" is a floating point number after all.

So something along these lines:

///comment the method assumptions here
///otherwise the method might seem wrong
public static double GetNumber(string numberString)
{
   bool hasDecimalComma = numberString.Contains(',');
   if (hasDecimalComma)
     numberString = numberString.Replace(',', '.')
   double result;
   bool success = double.TryParse(numberString, 
                      NumberStyles.Float, 
                      CultureInfo.InvariantCulture,
                      out result);
   if (success)
     return result;
   else 
     throw new ArgumentException(
                           string.Format("can't parse '{0}'", numberString));
}

(Old answer, good in principle, impossible in practice)

I would suggest storing the generating culture along the string, and then using it to call the method, along these lines (using double.TryParse):

public static double GetNumber(string numberString, CultureInfo culture)
{
   double result;
   bool success = double.TryParse(numberString, 
                          NumberStyles.Float | NumberStyles.AllowThousands, 
                          culture,
                          out result);
   if (success)
      return result;
   else 
      throw new ArgumentException(
                               string.Format("can't parse '{0}'", numberString));
}

Changed the answer in light of that. – SWeko Sep 02 '13 at 11:51 — SWeko, Sep 02 '13 at 11:51

score 0 · Answer 3 · answered Sep 02 '13 at 12:54

Just use the current culture and correct number format flags. Of couse, you have to test it against all cultures that are potentially stored in your database. Better: convert numbers to CultureInfo.Invariant culture before even storing them into the database. Or: Store also the culture identifier when storing the number.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            const string toTest = "1.006,30";

            float number;
            if (float.TryParse(toTest, NumberStyles.AllowDecimalPoint | NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.CurrentCulture, out number))
                Console.WriteLine("Success: {0}", number);
            else
                Console.WriteLine("Failure: strange number format");

            Console.WriteLine("Press any key to finish");
            Console.ReadKey();
        }
    }
}

score 0 · Answer 4 · answered Sep 06 '13 at 13:31

Unless some of your clients is using Persian (fa, fa-IR tag) as their culture, I think you're good to go:

// apparently, Persians use '/' as the decimal separator
var slash = CultureInfo
    .GetCultures(CultureTypes.AllCultures)
    .Where(c => 
        c.NumberFormat.NumberDecimalSeparator != "," && 
        c.NumberFormat.NumberDecimalSeparator != ".")
    .ToList();

Cross-regional decimal/double parsing

4 Answers4

Linked