71

如何在 C# 中将任何值舍入到 10 间隔？例如，如果我有 11，我希望它返回 10，如果我有 136，那么我希望它返回 140。

我可以很容易地用手做

return ((int)(number / 10)) * 10;

但我正在寻找一种内置算法来完成这项工作，比如 Math.Round()。我不想手动做的原因是我不想在我的项目中编写相同或相似的代码，即使是像上面这样简单的事情。

4

6 回答 6

110

类库中没有内置函数可以执行此操作。最接近的是System.Math.Round()，它仅用于将 Decimal 和 Double 类型的数字舍入到最接近的整数值。但是，如果您使用的是 .NET 3.5，则可以将语句包装在扩展方法中，这将使您可以更干净地使用该函数。

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

如果您正在针对旧版本的 .NET 框架进行编程，只需从 RoundOff 函数中删除“this”，然后像这样调用该函数：

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10
于 2008-11-08T07:13:29.223 回答
25

使用 Math.Ceiling 总是四舍五入。

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

Modulus(%) 得到余数，所以你得到：

// number = 236 + 10 - 6

将其放入扩展方法中

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

以上编辑：我本应本能地使用 Math.Ceiling

我在计算 UPC 校验位时写了一篇博客。

于 2008-11-08T06:22:17.860 回答
15

这可能有点太晚了，但我想有一天这可能会有所帮助......

我试过这个：

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

要使用：

int number = 11;
int roundednumber = RoundOff(number, 10);

这样，您可以选择将间隔的一半向上舍入还是向下舍入。=)

于 2009-11-24T07:16:18.870 回答
5

将浮点数舍入为整数类似于 (int)(x+0.5)，而不是简单地转换 x - 如果您想要 10 的倍数，您可以轻松适应它。

如果您只想进行整数数学并将其四舍五入到十，请尝试 (x+10/2)/10*10。

编辑：我注意到这个回复不符合原作者的要求，也是一种我不喜欢做的有偏见的四舍五入形式。然而，另一个接受的回应已经指出 Math.round()，这是一个更好的解决方案。

于 2008-11-08T06:18:12.660 回答
3

老问题，但这里有一种方法可以完成所要求的事情，而且我将其扩展为能够将任何数字四舍五入到你想要的 sig figs 的数量。

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }
于 2013-01-24T04:24:08.760 回答
2

我宁愿不引入Math库也不要使用浮点数，所以我的建议是像下面这样进行整数运算，然后向上舍入到下一个 1K。如果您不想重复，请将其包装在方法或 lambda 片段或其他内容中。

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

我没有对这种方式与其他方式进行性能测试，但我敢打赌这是最快的方式来保存可能是位的移位和旋转版本。

于 2012-08-06T04:56:07.060 回答