Converter -> public static int ToInt32(double value) 你用对了么？

Convert.ToInt32()  是我们经常使用的方法，但如果我们写如下的代码，能确定它的输出值么？

 var x = 7.5;
 Console.WriteLine(7.5 + ": " + Convert.ToInt32(x));
 x = 6.5;
 Console.WriteLine(6.5 + ": " + Convert.ToInt32(x));

让我意外的是，它的输出为：

7.5: 8
6.5: 6

有点疑惑，所以用Reflector看下了代码：

[__DynamicallyInvokable]
public static int ToInt32(double value)
{
    if (value >= 0.0)
    {
        if (value < 2147483647.5)
        {
            int num = (int) value;
            double num2 = value - num;
            if ((num2 > 0.5) || ((num2 == 0.5) && ((num & 1) != 0)))
            {
                num++;
            }
            return num;
        }
    }
    else if (value >= -2147483648.5)
    {
        int num3 = (int) value;
        double num4 = value - num3;
        if ((num4 < -0.5) || ((num4 == -0.5) && ((num3 & 1) != 0)))
        {
            num3--;
        }
        return num3;
    }
    throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
}

 

 
 1 0x1[__DynamicallyInvokable]
public static int ToInt32(double value)
{
    if (value >= 0.0)
    {
        if (value < 2147483647.5)
        {
            int num = (int) value;
            double num2 = value - num;
            if ((num2 > 0.5) || ((num2 == 0.5) && ((num & 1) != 0)))
            {
                num++;
            }
            return num;
        }
    }
    else if (value >= -2147483648.5)
    {
        int num3 = (int) value;
        double num4 = value - num3;
        if ((num4 < -0.5) || ((num4 == -0.5) && ((num3 & 1) != 0)))
        {
            num3--;
        }
        return num3;
    }
    throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
}

 

6-15行的处理说明了问题，((num2 == 0.5) && ((num & 1) != 0) 判断如果是奇数，那么结果自增，否则不处理。Why？ 为什么要这么处理？ google了一下，发现.net的四舍五入都会使用“银行家四舍五入算法”：

The History section of the Wikipedia entry for Rounding has some statements about the role of "round to even" in computing. Interestingly, it appears "Bankers Rounding" has little evidence to state it was official in any sense of the word, so can only be chalked up as slang terminology.

It is only "more logical" if you subscribe to that rounding mechanism. Bankers rounding (which is the default in this case) is also perfectly logical.

Imagine if banks rounded up to the nearest penny for every fractional amount, they would make a lot less (lose a lot of, for the cynical) money with the millions upon millions of transactions that are processed daily. OK, so this example is cynical.

Going towards the nearest even number (or odd, but history chose otherwise) means that not every rounding resolution goes up, some can now go down. When you put this to the law of averages, it becomes a fair solution to use when considering who is responsible for paying for the extra half penny.

As for why this was chosen for the framework, this question attempts to address it:

Why does .NET use banker's rounding as default?

Of course, this all harks back to financial days and its applicability to integral numbers could be questioned, but why bother? Accept it, override it if you want to, just understand how it works.

 

请参阅：

http://stackoverflow.com/questions/11431793/convert-toint32-rounds-to-the-nearest-even-number

http://stackoverflow.com/questions/311696/why-does-net-use-bankers-rounding-as-default