简单的方法是:

Math.Ceiling(decimal.Parse(yourNumber + ""));

Silverlight不支持midpointrsurround选项。 下面是Silverlight的一个扩展方法，它添加了midpointrsurround枚举:

public enum MidpointRounding
{
    ToEven,
    AwayFromZero
}

public static class DecimalExtensions
{
    public static decimal Round(this decimal d, MidpointRounding mode)
    {
        return d.Round(0, mode);
    }

    /// <summary>
    /// Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
    /// </summary>
    /// <param name="d">A Decimal number to be rounded.</param>
    /// <param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
    /// <returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
    public static decimal Round(this decimal d, int decimals, MidpointRounding mode)
    {
        if ( mode == MidpointRounding.ToEven )
        {
            return decimal.Round(d, decimals);
        }
        else
        {
            decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
            int sign = Math.Sign(d);
            return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
        }
    }
}

来源:http://anderly.com/2009/08/08/silverlight-midpoint-rounding-solution/

舍入的性质

考虑一下将一个包含分数的数字四舍五入为整数的任务。在这种情况下，舍入的过程是确定哪个整数最能代表要舍入的数字。

在普通或“算术”四舍五入中，很明显2.1、2.2、2.3和2.4四舍五入到2.0;2.6 2.7 2.8 2.9到3.0。

剩下的是2.5，与2.0相比，它更接近3.0。2.0和3.0之间的选择取决于你，两者都是同样有效的。

对于负数，-2.1、-2.2、-2.3和-2.4会变成-2.0;而-2.6、2.7、2.8和2.9在算术四舍五入下会变成-3.0。

对于-2.5，需要在-2.0和-3.0之间进行选择。

其他形式的舍入

“四舍五入”取任何小数点后的数字，并使其成为下一个“整”数。因此，不仅2.5和2.6要四舍五入到3.0,2.1和2.2也要四舍五入到3.0。

四舍五入使正数和负数都远离零。2.5到3.0和-2.5到-3.0。

“舍入”通过砍掉不需要的数字来截断数字。这样做的效果是将数字移向零。2.5到2.0和-2.5到-2.0

在“银行家四舍五入”中——最常见的形式——要四舍五入的。5要么四舍五入，要么四舍五入，这样四舍五入的结果总是偶数。因此，2.5轮到2.0,3.5轮到4.0,4.5轮到4.0,5.5轮到6.0，以此类推。

'交替四舍五入'将任何。5的过程在四舍五入和四舍五入之间交替进行。

“随机舍入”是在完全随机的基础上舍入0.5上下的数值。

对称与不对称

一个舍入函数是“对称的”，如果它把所有的数字舍入到零，或者把所有的数字舍入到零。

如果将正数舍入为零，将负数舍入为零，则函数是“不对称的”。2.5到2.0;从-2.5到-3.0。

同样不对称的还有一个函数，它把正数舍入为零，把负数舍入为零。2.5至3.0;从-2.5到-2.0。

大多数时候，人们会想到对称舍入，即-2.5会舍入到-3.0,3.5会舍入到4.0。(在c# Round(AwayFromZero))

这被称为舍入到偶数(或银行家舍入)，这是一种有效的舍入策略，可以最大限度地减少总和中的累积错误(MidpointRounding.ToEven)。理论是，如果你总是在同一个方向四舍五入一个0.5的数字，误差会更快地累积(四舍五入到偶数应该是最小化)(a)。

以下是MSDN对以下内容的描述:

Math.Floor, which rounds down towards negative infinity. Math.Ceiling, which rounds up towards positive infinity. Math.Truncate, which rounds up or down towards zero. Math.Round, which rounds to the nearest integer or specified number of decimal places. You can specify the behavior if it's exactly equidistant between two possibilities, such as rounding so that the final digit is even ("Round(2.5,MidpointRounding.ToEven)" becoming 2) or so that it's further away from zero ("Round(2.5,MidpointRounding.AwayFromZero)" becoming 3).

下面的图表可能会有所帮助:

-3        -2        -1         0         1         2         3
 +--|------+---------+----|----+--|------+----|----+-------|-+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round(ToEven)            -3       0      0      2      3
Round(AwayFromZero)      -3      -1      0      2      3

请注意，Round比它看起来强大得多，因为它可以舍入到特定的小数点后数位。其他的都是0小数。例如:

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

对于其他函数，你必须使用乘除技巧来达到相同的效果:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15

(a)当然，这个理论取决于这样一个事实，即你的数据在偶数一半(0.5,2.5,4.5，…)和奇数一半(1.5,3.5，…)之间的值分布相当均匀。

如果所有的“半值”都是偶数(例如)，错误就会像你总是四舍五入一样快速累积。

这是非常丑陋的，但总是产生正确的算术四舍五入。

public double ArithRound(double number,int places){

  string numberFormat = "###.";

  numberFormat = numberFormat.PadRight(numberFormat.Length + places, '#');

  return double.Parse(number.ToString(numberFormat));

}

简单的方法是:

Math.Ceiling(decimal.Parse(yourNumber + ""));