Decimal.Round Método

Definição

Arredonda um valor para o inteiro ou número especificado de casas decimais mais próximo.

Sobrecargas

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para a precisão especificada usando a estratégia de arredondamento especificada.

Round(Decimal, MidpointRounding)

Arredonda um valor decimal para um inteiro usando a estratégia de arredondamento especificada.

Round(Decimal)

Arredonda um valor decimal para o inteiro mais próximo.

Round(Decimal, Int32)

Arredonda um valor Decimal para um número especificado de casas decimais.

Round(Decimal, Int32, MidpointRounding)

Origem:
Decimal.cs
Origem:
Decimal.cs
Origem:
Decimal.cs

Arredonda um valor decimal para a precisão especificada usando a estratégia de arredondamento especificada.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

decimals
Int32

O número de casas decimais significativas (precisão) no valor retornado.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

O número arredondado d para usar a mode estratégia de arredondamento e com uma precisão de decimals. Se a precisão de d for menor que decimals, d será retornado inalterado.

Implementações

Exceções

decimals é menor que 0 ou maior que 28.

mode não é um valor MidpointRounding.

O resultado está fora do intervalo de um objeto Decimal.

Exemplos

O exemplo a seguir demonstra como usar o Round(Decimal, Int32, MidpointRounding) método com a MidpointRounding enumeração .

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)
*/
// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{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.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{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)
'

Comentários

O decimals parâmetro especifica o número de casas decimais significativas no valor retornado e varia de 0 a 28. Se decimals for zero, um inteiro será retornado.

Se você especificar ToEven ou AwayFromZero para o mode parâmetro , essas estratégias de arredondamento só serão aplicadas para valores de ponto médio, ou seja, valores cujo dígito menos significativo é 5.

Confira também

Aplica-se a

Round(Decimal, MidpointRounding)

Origem:
Decimal.cs
Origem:
Decimal.cs
Origem:
Decimal.cs

Arredonda um valor decimal para um inteiro usando a estratégia de arredondamento especificada.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

mode
MidpointRounding

Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.

Retornos

O inteiro arredondado d para usar a mode estratégia de arredondamento.

Implementações

Exceções

mode não é um valor MidpointRounding.

O resultado está fora do intervalo de um objeto Decimal.

Exemplos

O exemplo a seguir exibe valores retornados pelo Round(Decimal, MidpointRounding) método com argumentos diferentes 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
printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// 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

Comentários

Se você especificar ToEven ou AwayFromZero para o mode parâmetro , essas estratégias de arredondamento só serão aplicadas para valores de ponto médio, ou seja, valores cujo dígito menos significativo é 5.

Confira também

Aplica-se a

Round(Decimal)

Origem:
Decimal.cs
Origem:
Decimal.cs
Origem:
Decimal.cs

Arredonda um valor decimal para o inteiro mais próximo.

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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

Retornos

O inteiro mais próximo ao parâmetro d. Se d estiver entre dois inteiros, sendo um deles par e outro ímpar, o número par será retornado.

Implementações

Exceções

O resultado está fora do intervalo de um valor Decimal.

Exemplos

O exemplo a seguir arredonda um intervalo de Decimal valores entre 100 e 102 para o inteiro mais próximo. Como o método usa o arredondamento do banqueiro, 100,5 arredonda para 100 e 101,5 arredonda para 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
open System

for value in 100m .. 0.1m .. 102m do
    printfn $"{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

Comentários

O comportamento deste método segue o padrão IEEE 754, seção 4. Esse tipo de arredondamento às vezes é chamado de meia rodada para oarredondamento par ou banqueiro. Ele minimiza erros de arredondamento resultantes do arredondamento consistente de um valor de ponto médio em uma única direção. É equivalente a chamar o Round(Decimal, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven.

Confira também

Aplica-se a

Round(Decimal, Int32)

Origem:
Decimal.cs
Origem:
Decimal.cs
Origem:
Decimal.cs

Arredonda um valor Decimal para um número especificado de casas decimais.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public:
 static System::Decimal Round(System::Decimal d, int decimals) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.

decimals
Int32

Um valor de 0 a 28 que especifica o número de casas decimais para o qual arredondar.

Retornos

O número decimal equivalente a d arredondado para decimals casas decimais.

Implementações

Exceções

decimals não é um valor de 0 a 28.

Exemplos

O exemplo a seguir arredonda vários Decimal valores para um número especificado de casas decimais usando o Round método .

using System;

class Example12
{
   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
open System

// Define a set of Decimal values.
let values = 
    [ 1.45m; 1.55m; 123.456789m; 123.456789m
      123.456789m; -123.456m
      Decimal(1230000000, 0, 0, true, 7uy)
      Decimal(1230000000, 0, 0, true, 7uy)
      -9999999999.9999999999m
      -9999999999.9999999999m ]

// Define a set of integers to for decimals argument.
let decimals = 
    [ 1; 1; 4; 6; 8; 0; 3; 11; 9; 10 ]

printfn $"""{"Argument",26}{"Digits",8}{"Result",26}"""
printfn $"""{"--------",26}{"------",8}{"------",26}"""

for i = 0 to values.Length - 1 do
    printfn $"{values[i],26}{decimals[i],8}{Decimal.Round(values[i], decimals[i]),26}"

// 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

Comentários

Esse método é equivalente a chamar o Round(Decimal, Int32, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven. Quando d está exatamente na metade entre dois valores arredondados, o resultado é o valor arredondado que tem um dígito par na posição decimal de extrema direita. Por exemplo, quando arredondado para duas casas decimais, o valor 2.345 torna-se 2.34 e 2.355 torna-se o valor 2.36. Esse processo é conhecido como arredondamento até mesmo, ou arredondamento do banqueiro. Ele minimiza erros de arredondamento resultantes do arredondamento consistente de um valor de ponto médio em uma única direção.

Confira também

Aplica-se a