如何在C#中向上或向下取整？

我试过用数学。圆和中点圆。这似乎不能满足我的需要

例如：

52.34567 rounded to 2 decimals UP   = 52.35  
 1.183   rounded to 2 decimals DOWN =  1.18

Rounding.RoundDown(23.567, 2) prints 23.56

我是否需要编写自定义函数

编辑：

我应该说得更具体些

有时我需要23.567这样的数字才能四舍五入到23.56。 在这个场景中

Math.Round(dec, 2, MidpointRounding.AwayFromZero) gives 23.57
Math.Round(dec, 2, MidpointRounding.ToEven) gives 23.57

小数位数最多为9位，需要四舍五入到1、2、3甚至4位。

尝试使用decimal.Round（）

其中，

x

是您的值，2是您希望保留的小数位数

您还可以通过传递第三个参数来指定.5是向上舍入还是向下舍入：

decimal.Round(x, 2, MidpointRounding.AwayFromZero);

编辑：

根据新的要求（即数字有时会向下舍入，尽管距离下一个间隔的距离大于“一半”），您可以尝试：

var pow = Math.Pow(10, numDigits);
var truncated = Math.Truncate(x*pow) / pow;

Truncate（）删除小数的非整数部分。请注意，上面的

numDigits

应该是您要保留的位数，而不是小数总数等

---

最后，如果要强制向上取整（截断实际上是强制向下取整），只需在再次除法之前向

Truncate（）

调用的结果中添加1即可。

尝试使用

Math.Ceiling

（向上）或

Math.Floor

（向下）。e、 g

Math.Floor（1.8）==1。

假设您对数字使用的是

decimal

类型

static class Rounding
{
    public static decimal RoundUp(decimal number, int places)
    {
        decimal factor = RoundFactor(places);
        number *= factor;
        number = Math.Ceiling(number);
        number /= factor;
        return number;
    }

    public static decimal RoundDown(decimal number, int places)
    {
        decimal factor = RoundFactor(places);
        number *= factor;
        number = Math.Floor(number);
        number /= factor;
        return number;
    }

    internal static decimal RoundFactor(int places)
    {
        decimal factor = 1m;

        if (places < 0)
        {
            places = -places;
            for (int i = 0; i < places; i++)
                factor /= 10m;
        }

        else
        {
            for (int i = 0; i < places; i++)
                factor *= 10m;
        }

        return factor;
    }
}

---

对于接受答案的简短版本，以下是可使用的

RoundUp

和

RoundDown

函数：

public double RoundDown(double number, int decimalPlaces)
{
    return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
}

public double RoundUp(double number, int decimalPlaces)
{
    return Math.Ceiling(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
}

也许是这个

Math.Round(dec + 0.5m, MidpointRounding.AwayFromZero);

---

用结果完成代码

  double a = Math.Round(128.5, 0, MidpointRounding.AwayFromZero);

---

结果为129

尝试此自定义舍入

public int Round(double value)
{
    double decimalpoints = Math.Abs(value - Math.Floor(value));
    if (decimalpoints > 0.5)
        return (int)Math.Round(value);
    else
        return (int)Math.Floor(value);
}

---

Math

类提供了用于上下取整的方法，它们分别是

Math.天花（）

和

Math.Floor（）

。它们的工作方式类似于

Math.Round（）

，但它们有一个特殊性，它们只接收一个值并将其四舍五入到整个部分

因此，您需要使用

Math.Pow（）

将该值乘以10，得到n个小单位，然后再除以相同的乘以值

请务必注意，

Math.Pow（）

方法的输入参数是

double

，因此需要将它们转换为

double

例如：

如果要将值四舍五入到3位小数（假设值类型为

decimal

）：

如果要将值向下舍入到3位小数（假设值类型为

decimal

）：

要参考如何更具体地使用它们，并获取更多信息以及关于这两种方法的信息，您可以从官方MSDN Microsoft网站上查看以下页面：

---

您可以使用Math.Round（）或decimal.Round（）的方法来实现这一点：

---

你试过乘100，四舍五入，再除以100吗？你能展示一下你用来做四舍五入的代码吗？这似乎对我有用。也许我误解了这个问题

Response.Write（Math.Round（52.34567,2.ToString（））输出：52.35显然他还没有试过，因为这正是他所需要的。他甚至可以自己测试：
Console.WriteLine（Math.Round（52.34567,2））和
Console.WriteLine（数学圆（1.183,2））这些是很好的函数，但是，它们强制值为整数。在许多情况下，我需要维护小数。如果你想对小数进行维护，你可以这样做：
Math.Floor（1.87*10）/10==1.8
你也可以轻松修改这个例子，为小数类型创建扩展方法，例如公共静态小数舍入（这个小数，int位）
public int Round(double value)
{
    double decimalpoints = Math.Abs(value - Math.Floor(value));
    if (decimalpoints > 0.5)
        return (int)Math.Round(value);
    else
        return (int)Math.Floor(value);
}

double decimalsNumber = 3;
decimal valueToRound = 1.1835675M;
// powerOfTen must be equal to 10^3 or 1000.
double powerOfTen = Math.Pow(10, decimalsNumber);
// rounded must be equal to Math.Ceiling(1.1835675 * 1000) / 1000
decimal rounded = Math.Ceiling(valueToRound * (decimal)powerOfTen) / (decimal)powerOfTen;


Result: rounded = 1.184

double decimalsNumber = 3;
decimal valueToRound = 1.1835675M;
// powerOfTen must be equal to 10^3 or 1000.
double powerOfTen = Math.Pow(10, decimalsNumber);
// rounded must be equal to Math.Floor(1.1835675 * 1000) / 1000
decimal rounded = Math.Floor(valueToRound * (decimal)powerOfTen) / (decimal)powerOfTen;


Result: rounded = 1.183

Math.Round(amt)
Math.Round(amt, Int32) and other overloading methods.


decimal.Round(amt)
decimal.Round(amt, 2) and other overloding methods.