Decimal.Round 메서드

정의

값을 가장 가까운 정수나 지정된 소수 자릿수로 반올림합니다.

오버로드

Round(Decimal)

10진 값을 가장 가까운 정수로 반올림합니다.

Round(Decimal, Int32)

Decimal 값을 지정된 소수 자릿수로 반올림합니다.

Round(Decimal, MidpointRounding)

지정된 반올림 전략을 사용하여 10진수 값을 정수로 반올림합니다.

Round(Decimal, Int32, MidpointRounding)

지정된 반올림 전략을 사용하여 10진수 값을 지정된 전체 자릿수로 반올림합니다.

Round(Decimal)

10진 값을 가장 가까운 정수로 반올림합니다.

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

반올림할 10진수입니다.

반환

Decimal

d 매개 변수에 가장 가까운 정수입니다. d가 두 숫자의 중간에 있으며 이 숫자 중 하나는 짝수이고 다른 하나는 홀수이면 짝수가 반환됩니다.

예외

결과가 Decimal 값의 범위를 벗어났습니다.

예제

다음 예제에서는 Decimal 100에서 102 사이의 값 범위를 가장 가까운 정수로 반올림합니다. 메서드는 100.5를 100으로 반올림하고 101.5를 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를 따릅니다. 이러한 종류의 반올림을 짝수 또는 짝수의 반올림으로 반올림이라고도 합니다. 중간점 값을 한 방향으로 일관되게 반올림하여 발생하는 반올림 오류를 최소화합니다. 인수를 사용하여 메서드를 호출하는 것과 Round(Decimal, MidpointRounding) mode MidpointRounding.ToEven 같습니다.

추가 정보

적용 대상

Round(Decimal, Int32)

Decimal 값을 지정된 소수 자릿수로 반올림합니다.

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

반올림할 10진수입니다.

decimals
Int32

반올림할 소수 자릿수를 지정하는 0부터 28까지의 값입니다.

반환

Decimal

소수 자릿수로 반올림된 에 해당하는 d decimals 10진수입니다.

예외

decimals이 0~28 사이의 값이 아닙니다.

예제

다음 예제에서는 Decimal 메서드를 사용하여 여러 값을 지정된 소수 자릿수로 반올림합니다. Round

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이 반올림된 두 값의 중간에 있는 경우 결과는 맨 오른쪽 소수 위치에 짝수 자릿수가 있는 반올림된 값입니다. 예를 들어, 소수점 두 자리로 반올림하면 2.345는 2.34가 되고 2.355는 2.36이 됩니다. 이 프로세스를 짝수 또는 짝수의 반올림으로 반올림이라고 합니다. 중간점 값을 한 방향으로 일관되게 반올림하여 발생하는 반올림 오류를 최소화합니다.

추가 정보

적용 대상

Round(Decimal, MidpointRounding)

지정된 반올림 전략을 사용하여 10진수 값을 정수로 반올림합니다.

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

반올림할 10진수입니다.

mode
MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Decimal

d반올림 전략을 사용하여 반올림되는 정수입니다. mode

예외

modeMidpointRounding 값이 아닙니다.

결과가 Decimal 개체의 범위를 벗어났습니다.

예제

다음 예제에서는 다른 인수를 사용 하는 메서드에서 반환 된 값을 표시 Round(Decimal, MidpointRounding) mode 합니다.

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

설명

매개 변수에 대해 또는 를 지정하는 경우 ToEven AwayFromZero 이러한 반올림 전략은 중간점 값, 즉 최소 유효 mode 자릿수가 5인 값에만 적용됩니다.

추가 정보

적용 대상

Round(Decimal, Int32, MidpointRounding)

지정된 반올림 전략을 사용하여 10진수 값을 지정된 전체 자릿수로 반올림합니다.

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

반올림할 10진수입니다.

decimals
Int32

반환 값에서 유효 소수 자릿수(전체 자릿수)의 숫자입니다.

mode
MidpointRounding

사용할 반올림 전략을 지정하는 열거형 값 중 하나입니다.

반환

Decimal

반올림 전략을 사용하고 전체 자릿수를 사용하여 로 d mode 반올림되는 decimals 숫자입니다. d의 전체 자릿수가 decimals보다 작으면 d는 변경되지 않은 상태로 반환됩니다.

예외

decimals가 0보다 작거나 28보다 큽니다.

modeMidpointRounding 값이 아닙니다.

결과가 Decimal 개체의 범위를 벗어났습니다.

예제

다음 예제에서는 사용 하는 방법에 설명 합니다 Round(Decimal, Int32, MidpointRounding) 메서드를 MidpointRounding 열거형입니다.

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

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

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/
Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' 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)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' 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)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        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.ToZero)
'
'        -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.ToZero)
'

설명

decimals매개 변수는 반환 값의 소수 자릿수를 지정하고 범위는 0에서 28까지입니다. decimals가 0이면 정수 가 반환됩니다.

매개 변수에 대해 또는 를 지정하는 경우 ToEven AwayFromZero 이러한 반올림 전략은 중간점 값, 즉 최소 유효 mode 자릿수가 5인 값에만 적용됩니다.

추가 정보

적용 대상