Decimal.Round 方法

定义

将值舍入到最接近的整数或指定的小数位数。Rounds a value to the nearest integer or specified number of decimal places.

重载

Round(Decimal)

将小数值舍入到最接近的整数。Rounds a decimal value to the nearest integer.

Round(Decimal, Int32)

Decimal 值舍入到指定的小数位数。Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding)

将小数值舍入到最接近的整数。Rounds a decimal value to the nearest integer. 一个参数,指定当一个值正好处于另两个数中间时如何舍入这个值。A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding)

将小数值舍入到指定精度。Rounds a decimal value to a specified precision. 一个参数,指定当一个值正好处于另两个数中间时如何舍入这个值。A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal)

将小数值舍入到最接近的整数。Rounds a decimal value to the nearest integer.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

参数

d
Decimal

要舍入的小数。A decimal number to round.

返回

最接近 d 参数的整数。The integer that is nearest to the d parameter. 如果 d 正好处于两个整数中间,其中一个整数为偶数,另一个整数为奇数,则返回偶数。If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

异常

结果在 Decimal 值范围之外。The result is outside the range of a Decimal value.

示例

下面的示例将介于100和102之间的 Decimal 值的范围舍入到最接近的整数。The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. 由于方法使用的是 "中舍入",因此请注意,100.5 舍入为100,101.5 舍入到102。Because the method uses banker's rounding, note that 100.5 rounds to 100 and 101.5 rounds to 102.

using System;

public class Example
{
   public static void Main()
   {
      for (decimal value = 100m; value <= 102m; value += .1m)
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value));

   }
}
// The example displays the following output:
//     100 --> 100
//     100.1 --> 100
//     100.2 --> 100
//     100.3 --> 100
//     100.4 --> 100
//     100.5 --> 100
//     100.6 --> 101
//     100.7 --> 101
//     100.8 --> 101
//     100.9 --> 101
//     101.0 --> 101
//     101.1 --> 101
//     101.2 --> 101
//     101.3 --> 101
//     101.4 --> 101
//     101.5 --> 102
//     101.6 --> 102
//     101.7 --> 102
//     101.8 --> 102
//     101.9 --> 102
//     102.0 --> 102
Module Example
   Public Sub Main()
      For value As Decimal = 100d To 102d Step .1d
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value))
      Next
   End Sub
End Module
' The example displays the following output:
'     100 --> 100
'     100.1 --> 100
'     100.2 --> 100
'     100.3 --> 100
'     100.4 --> 100
'     100.5 --> 100
'     100.6 --> 101
'     100.7 --> 101
'     100.8 --> 101
'     100.9 --> 101
'     101.0 --> 101
'     101.1 --> 101
'     101.2 --> 101
'     101.3 --> 101
'     101.4 --> 101
'     101.5 --> 102
'     101.6 --> 102
'     101.7 --> 102
'     101.8 --> 102
'     101.9 --> 102
'     102.0 --> 102

注解

此方法的行为遵循 IEEE 标准754第4部分。The behavior of this method follows IEEE Standard 754, section 4. 这种类型的舍入有时称为 "整半角",甚至称为 "银行家舍入"。This kind of rounding is sometimes called round half to even or banker's rounding. 它最大程度地减少了通过以单方向持续舍入点值而导致的舍入误差。It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. 它等效于使用 MidpointRounding.ToEvenmode 参数调用 Round(Decimal, MidpointRounding) 方法。It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

另请参阅

Round(Decimal, Int32)

Decimal 值舍入到指定的小数位数。Rounds a Decimal value to a specified number of decimal places.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

参数

d
Decimal

要舍入的小数。A decimal number to round.

decimals
Int32

指定数字要舍入到的小数位数的值,范围从 0 到 28。A value from 0 to 28 that specifies the number of decimal places to round to.

返回

舍入到 d 的小数位数等于 decimals 的小数位数。The decimal number equivalent to d rounded to decimals number of decimal places.

异常

decimals 不是一个介于 0 到 28 的值。decimals is not a value from 0 to 28.

示例

下面的示例使用 Round 方法将几个 Decimal 值舍入到指定的小数位数。The following example rounds several Decimal values to a specified number of decimal places using the Round method.

using System;

class Example
{
   public static void Main()
   {
      // Define a set of Decimal values.
      decimal[] values = { 1.45m, 1.55m, 123.456789m, 123.456789m, 
                           123.456789m, -123.456m, 
                           new Decimal(1230000000, 0, 0, true, 7 ),
                           new Decimal(1230000000, 0, 0, true, 7 ), 
                           -9999999999.9999999999m, 
                           -9999999999.9999999999m };
      // Define a set of integers to for decimals argument.
      int[] decimals = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10};
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" );
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" );
      for (int ctr = 0; ctr < values.Length; ctr++)
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values[ctr], decimals[ctr], 
                          Decimal.Round(values[ctr], decimals[ctr]));
    }
}
// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999
Public Module Example
   Public Sub Main()
      ' Define a set of Decimal values.
      Dim values() As Decimal = { 1.45d, 1.55d, 123.456789d, 123.456789d, 
                                  123.456789d, -123.456d, 
                                  New Decimal(1230000000, 0, 0, true, 7 ),
                                  New Decimal(1230000000, 0, 0, true, 7 ), 
                                  -9999999999.9999999999d, 
                                  -9999999999.9999999999d }
      ' Define a set of integers to for decimals argument.
      Dim decimals() As Integer = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" )
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" )
      For ctr As Integer = 0 To values.Length - 1
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values(ctr), decimals(ctr), 
                          Decimal.Round(values(ctr), decimals(ctr)))
      Next
   End Sub
End Module
' The example displays the following output:
'                   Argument  Digits                    Result
'                   --------  ------                    ------
'                       1.45       1                       1.4
'                       1.55       1                       1.6
'                 123.456789       4                  123.4568
'                 123.456789       6                123.456789
'                 123.456789       8                123.456789
'                   -123.456       0                      -123
'               -123.0000000       3                  -123.000
'               -123.0000000      11              -123.0000000
'     -9999999999.9999999999       9    -10000000000.000000000
'     -9999999999.9999999999      10    -9999999999.9999999999

注解

此方法等效于使用 MidpointRounding.ToEvenmode 参数调用 Round(Decimal, Int32, MidpointRounding) 方法。当 d 正好处于两个舍入值的正中间值时,结果是在最右小数点位置有偶数位的舍入值。This method is equivalent to calling the Round(Decimal, Int32, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.When d is exactly halfway between two rounded values, the result is the rounded value that has an even digit in the far right decimal position. 例如,当舍入为两位小数时,值 2.345 变成 2.34,而值 2.355 变成 2.36。For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. 此过程称为甚至舍**入的舍入This process is known as rounding toward even, or banker's rounding. 它最大程度地减少了通过以单方向持续舍入点值而导致的舍入误差。It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

另请参阅

Round(Decimal, MidpointRounding)

将小数值舍入到最接近的整数。Rounds a decimal value to the nearest integer. 一个参数,指定当一个值正好处于另两个数中间时如何舍入这个值。A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public static decimal Round (decimal d, MidpointRounding mode);
static member Round : decimal * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

参数

d
Decimal

要舍入的小数。A decimal number to round.

mode
MidpointRounding

一个值,指定当 d 正好处于另两个数字中间时如何舍入。A value that specifies how to round d if it is midway between two other numbers.

返回

最接近 d 参数的整数。The integer that is nearest to the d parameter. 如果 d 位于两个数字的中间,其中一个为偶数,另一个为奇数,则 mode 参数确定返回这两个数字中的哪一个。If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned.

异常

mode 不是 MidpointRounding 值。mode is not a MidpointRounding value.

结果在 Decimal 对象范围之外。The result is outside the range of a Decimal object.

示例

下面的示例显示 Round(Decimal) 方法返回的值、带有 ToEvenmode 参数的 Round(Decimal, MidpointRounding) 方法,以及 Round(Decimal, MidpointRounding) 参数为 modeAwayFromZero方法。The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value), 
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

注解

在中点值中,结果中的最小有效位后的值在两个数字之间精确到了一半。In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. 例如,如果要将舍入为整数,7.5 是中值。For example, 7.5 is a midpoint value if it is to be rounded to an integer. 对于中点值,不能轻松地识别最接近的值,因为它是由 mode 参数指定的。For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Round 方法支持两个用于处理中点值的舍入约定。The Round method supports two rounding conventions for handling midpoint values.

远离零的舍入。Rounding away from zero.
中值舍入到下一个数字,而不是零。Midpoint values are rounded to the next number away from zero. 例如,3.5 舍入为4,4.5 舍入为5,-3.5 舍入到-4,-4.5 舍入到-5。For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. 这种形式的舍入由 MidpointRounding.AwayFromZero 枚举成员表示。This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

远离零的舍入是最广泛的舍入形式。Rounding away from zero is the most widely known form of rounding.

舍入为偶数或按下舍入Rounding to even, or banker's rounding
中值舍入为最接近的偶数。Midpoint values are rounded to the nearest even number. 例如,3.5 和4.5 舍入为4,-3.5 和-4.5 舍入到-4。For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. 这种形式的舍入由 MidpointRounding.ToEven 枚举成员表示。This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

舍入到最接近的是在财务和统计操作中使用的标准舍入形式。Rounding to nearest is the standard form of rounding used in financial and statistical operations. 它符合 IEEE Standard 754,第4部分。It conforms to IEEE Standard 754, section 4. 当在多个舍入操作中使用时,它可减少因按单一方向持续舍入点值而导致的舍入误差。When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. 在某些情况下,此舍入误差很重要。In some cases, this rounding error can be significant.

另请参阅

Round(Decimal, Int32, MidpointRounding)

将小数值舍入到指定精度。Rounds a decimal value to a specified precision. 一个参数,指定当一个值正好处于另两个数中间时如何舍入这个值。A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

参数

d
Decimal

要舍入的小数。A decimal number to round.

decimals
Int32

返回值中的有效小数位数(精度)。The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

一个值,指定当 d 正好处于另两个数字中间时如何舍入。A value that specifies how to round d if it is midway between two other numbers.

返回

最接近 d 参数的数字,其精度等于 decimals 参数。The number that is nearest to the d parameter with a precision equal to the decimals parameter. 如果 d 位于两个数字的中间,其中一个为偶数,另一个为奇数,则 mode 参数确定返回这两个数字中的哪一个。If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned. 如果 d 的精度小于 decimals,则原样返回 dIf the precision of d is less than decimals, d is returned unchanged.

异常

decimals 小于 0 或大于 28。decimals is less than 0 or greater than 28.

mode 不是 MidpointRounding 值。mode is not a MidpointRounding value.

结果在 Decimal 对象范围之外。The result is outside the range of a Decimal object.

示例

下面的示例演示如何将 Round(Decimal, Int32, MidpointRounding) 方法与 MidpointRounding 枚举一起使用。The following example demonstrates how to use the Round(Decimal, Int32, MidpointRounding) method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
result = Math.Round(negValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(negValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
Console.WriteLine();
/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

注解

decimals 参数指定返回值中的有效小数位数,范围为0到28。The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. 如果 decimals 为零,则返回整数。If decimals is zero, an integer is returned.

在中点值中,结果中的最小有效位后的值在两个数字之间精确到了一半。In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. 例如,如果要将两个小数位舍入,3.47500 是中值,如果要将它舍入到整数,则7.500 为中点值。For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. 在这些情况下,如果没有舍入约定,则不能轻松地识别最接近的值,这是由 mode 参数指定的。In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Round(Decimal, Int32, MidpointRounding) 方法支持两个用于处理中点值的舍入约定。The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

远离零的舍入。Rounding away from zero.
中值舍入到下一个数字,而不是零。Midpoint values are rounded to the next number away from zero. 例如,3.75 舍入为3.8,3.85 舍入到3.9,-3.75 舍入到-3.8,-3.85 舍入到-3.9。For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. 这种形式的舍入由 MidpointRounding.AwayFromZero 枚举成员表示。This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

远离零的舍入是最广泛的舍入形式。Rounding away from zero is the most widely known form of rounding.

舍入为偶数或按下舍入Rounding to even, or banker's rounding
中值舍入为最接近的偶数。Midpoint values are rounded to the nearest even number. 例如,3.75 和3.85 舍入为3.8,-3.75 和-3.85 舍入到-3.8。For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. 这种形式的舍入由 MidpointRounding.ToEven 枚举成员表示。This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

舍入到最接近的是在财务和统计操作中使用的标准舍入形式。Rounding to nearest is the standard form of rounding used in financial and statistical operations. 它符合 IEEE Standard 754,第4部分。It conforms to IEEE Standard 754, section 4. 当在多个舍入操作中使用时,它可减少因按单一方向持续舍入点值而导致的舍入误差。When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. 在某些情况下,此舍入误差很重要。In some cases, this rounding error can be significant.

另请参阅

适用于