双数据类型，小数点后计算小数

Question

下面的方法应该返回“什么小数精度，尾随数字的数量，这个（双）值有什么？”的答案。当值看起来像 5900.43、5900.043 等等时，我做对了。当该方法收到 5900.00 时，它返回 0，这是错误的（在我的需要中）。

   /// <summary>
   /// Return count of decimals after decimal-place 
   /// </summary>
   private int getDecimalCount(double val)
   {
        int count = 0;
        ...
        return count;
   }

当参数“val”为（此方法的正常值样本）时

5900.00 返回 2
5900.09 返回 2
5900.000 返回 3
5900.001 返回 3
1.0 返回 1
0.0000005 返回 7
1.0000000 返回 7
5900822 返回 0

我的问题是计算 .0 .00 .000 等等

问题：
我该如何解决这个问题？如果这种方法不能用于双打，还有什么办法？

[已编辑]
- 对文本进行细微更改以提出更清晰的问题，
- 由于“小数位”的误用含义而导致的语言更正

Answer 1

编辑：更新以简化不同文化的处理。

与@Miguel 类似，这就是我的处理方式：

public static int getDecimalCount(double dVal, string sVal, string culture)
{
    CultureInfo info = CultureInfo.GetCultureInfo(culture);

    //Get the double value of the string representation, keeping culture in mind
    double test = Convert.ToDouble(sVal, info);

    //Get the decimal separator the specified culture
    char[] sep = info.NumberFormat.NumberDecimalSeparator.ToCharArray();

    //Check to see if the culture-adjusted string is equal to the double
    if (dVal != test)
    {
        //The string conversion isn't correct, so throw an exception
        throw new System.ArgumentException("dVal doesn't equal sVal for the specified culture");
    }

    //Split the string on the separator 
    string[] segments = sVal.Split(sep);

    switch (segments.Length)
    {
        //Only one segment, so there was not fractional value - return 0
        case 1:
            return 0;
        //Two segments, so return the length of the second segment
        case 2:
            return segments[1].Length;

        //More than two segments means it's invalid, so throw an exception
        default:
            throw new Exception("Something bad happened!");
    }
}

还有一个美式英语的捷径：

public static int getDecimalCount(double dVal, string sVal)
{
    return getDecimalCount(dVal, sVal, "en-US");
}

测试：

static void Main(string[] args)
{
    int i = 0;

    double d = 5900.00; 
    string s = "5900.00";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 2. Actual output: {0}", i);
    Console.WriteLine();

    d = 5900.09;
    s = "5900.09";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 2. Actual output: {0}", i);
    Console.WriteLine();

    d = 5900.000;
    s = "5900.000";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 3. Actual output: {0}", i);
    Console.WriteLine();

    d = 5900.001;
    s = "5900.001";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 3. Actual output: {0}", i);
    Console.WriteLine();

    d = 1.0; 
    s = "1.0";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 1. Actual output: {0}", i);
    Console.WriteLine();

    d = 0.0000005; 
    s = "0.0000005";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 7. Actual output: {0}", i);
    Console.WriteLine();

    d = 1.0000000; 
    s = "1.0000000";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 7. Actual output: {0}", i);
    Console.WriteLine();

    d = 5900822; 
    s = "5900822";
    Console.WriteLine("Testing with dVal = {0} and sVal = {1}.", d, s);
    i = getDecimalCount(d, s);
    Console.WriteLine("Expected output: 0. Actual output: {0}", i);

    Console.ReadLine();
}

最后是测试的输出：

使用 dVal = 5900 和 sVal = 5900.00 进行测试。 预期输出：2。实际输出：2

使用 dVal = 5900.09 和 sVal = 5900.09 进行测试。 预期输出：2。实际输出：2

使用 dVal = 5900 和 sVal = 5900.000 进行测试。 预期输出：3。实际输出：3

使用 dVal = 5900.001 和 sVal = 5900.001 进行测试。 预期输出：3。实际输出：3

使用 dVal = 1 和 sVal = 1.0 进行测试。 预期输出：1。实际输出：1

使用 dVal = 5E-07 和 sVal = 0.0000005 进行测试。 预期输出：7。实际输出：7

使用 dVal = 1 和 sVal = 1.0000000 进行测试。 预期输出：7。实际输出：7

使用 dVal = 5900822 和 sVal = 5900822 进行测试。 预期输出：0。实际输出：0

如果您对此有任何疑问或没有意义，请告诉我。

Answer 2

您正在考虑双精度的字符串表示。例如，双精度在这些之间没有区别：

123
123.0
123.000000

这都是相同的双精度数，您得到多少小数位，实际上取决于您的字符串格式选项（或默认设置）。您可以做的是将您的双打格式化为带有很多小数位的字符串，然后去除所有尾随零，然后计算小数位。

Answer 3

创建一个接收字符串而不是双精度的方法：

    public int CountDecimalDigits(string value)
    {
        char[] possibleChars = "0123456789.".ToCharArray();
        int decimalPoints = 0;
        foreach (char ch in value)
        {
            if (Array.IndexOf(possibleChars, ch) < 0)
                throw new Exception();
            if (ch == '.') decimalPoints++;
        }
        if (decimalPoints > 1)
            throw new Exception();
        if (decimalPoints == 0) return 0;
        return value.Length - value.IndexOf('.') - 1;
    }

Answer 4

这不是被要求的，但这是我需要的。也许它会帮助某人：

 private static int getDecimalCount(double val)
 {
     int i=0;
     while (Math.Round(val, i) != val)
         i++;
     return i;
 }
double val1 = 5900.00; int count1 = getDecimalCount(val1);//result: 0
double val2 = 5900.09; int count2 = getDecimalCount(val2);//result: 2
double val3 = 5900.000; int count3 = getDecimalCount(val3);//result: 0
double val4 = 1.0; int count4 = getDecimalCount(val4);//result: 0
double val5 = 0.0000005; int count5 = getDecimalCount(val5);//result: 7
double val6 = 1.0000000; int count6 = getDecimalCount(val6);//result: 0
double val7 = 5900822; int count7 = getDecimalCount(val7);//result: 0

double val9 = 4.5565d; int count9 = getDecimalCount(val9);//result: 4