Decimal.Round Decimal.Round Decimal.Round Decimal.Round Method

定義

將值捨入至最接近的整數或是指定的小數位數數字。Rounds a value to the nearest integer or specified number of decimal places.

多載

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

將十進位值四捨五入為最接近的整數。Rounds a decimal value to the nearest integer.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Decimal 值捨入為指定的小數位數。Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) 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) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) 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) Round(Decimal) Round(Decimal) 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 Decimal Decimal 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和Decimal 102 之間的值範圍四捨五入到最接近的整數。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 Standard 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. 這相當於呼叫Round(Decimal, MidpointRounding) mode具有之引數MidpointRounding.ToEven的方法。It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

另請參閱

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) 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 Decimal Decimal Decimal

要捨入的十進位數字。A decimal number to round.

decimals
Int32 Int32 Int32 Int32

從 0 到 28 的值,這個值指定要捨入到的小數位數。A value from 0 to 28 that specifies the number of decimal places to round to.

傳回

十進位數字,等於捨入為 d 小數位數的 decimalsThe 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

備註

這個方法相當於呼叫Round(Decimal, Int32, MidpointRounding) mode具有之MidpointRounding.ToEven引數的方法。當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) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) 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 Decimal Decimal Decimal

要捨入的十進位數字。A decimal number to round.

mode
MidpointRounding MidpointRounding MidpointRounding 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.

例外狀況

結果超出 Decimal 物件的範圍。The result is outside the range of a Decimal object.

範例

下列範例會顯示Round(Decimal)方法所傳回的值Round(Decimal, MidpointRounding) 、具有mode ToEven mode引數的方法,以及Round(Decimal, MidpointRounding)具有之AwayFromZero引數的方法。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) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) 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 Decimal Decimal Decimal

要捨入的十進位數字。A decimal number to round.

decimals
Int32 Int32 Int32 Int32

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

mode
MidpointRounding MidpointRounding MidpointRounding 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,則 d 傳回時不會變更。If the precision of d is less than decimals, d is returned unchanged.

例外狀況

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

結果超出 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.

另請參閱

適用於