Decimal.Round Método
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Arredonda um valor para o número inteiro mais próximo ou especificado de casas decimais.
Sobrecargas
| Name | Description |
|---|---|
| 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 número inteiro mais próximo. |
| Round(Decimal, Int32) |
Arredonda um Decimal valor para um número especificado de casas decimais. |
Round(Decimal, Int32, MidpointRounding)
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- 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) = System::Numerics::IFloatingPoint<System::Decimal>::Round;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 -> decimalPublic Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As DecimalParâmetros
- d
- Decimal
Um número decimal para arredondar.
- decimals
- Int32
O número de casas decimais significativas (precisão) no valor de retorno.
- mode
- MidpointRounding
Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.
Devoluções
O número que d é arredondado para usando a mode estratégia de arredondamento e com uma precisão de decimals. Se a precisão de d for menor que decimals, d é devolvido inalterado.
Implementações
Exceções
decimals é inferior a 0 ou superior a 28.
mode não é um MidpointRounding valor.
O resultado está fora do alcance de um Decimal objeto.
Exemplos
O exemplo seguinte 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)
'
Observações
O decimals parâmetro especifica o número de casas decimais significativas no valor de retorno e varia de 0 a 28. Se decimals for zero, um inteiro é devolvido.
Se especificar ToEven ou AwayFromZero para o mode parâmetro, essas estratégias de arredondamento são aplicadas apenas para valores de ponto médio, ou seja, valores cujo dígito menos significativo é 5.
Ver também
Aplica-se a
Round(Decimal, MidpointRounding)
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- 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) = System::Numerics::IFloatingPoint<System::Decimal>::Round;public:
static System::Decimal Round(System::Decimal d, MidpointRounding mode);public static decimal Round(decimal d, MidpointRounding mode);static member Round : decimal * MidpointRounding -> decimalPublic Shared Function Round (d As Decimal, mode As MidpointRounding) As DecimalParâmetros
- d
- Decimal
Um número decimal para arredondar.
- mode
- MidpointRounding
Um dos valores de enumeração que especifica qual estratégia de arredondamento usar.
Devoluções
O inteiro arredondado d para usando a mode estratégia de arredondamento.
Implementações
Exceções
mode não é um MidpointRounding valor.
O resultado está fora do alcance de um Decimal objeto.
Exemplos
O exemplo seguinte mostra valores devolvidos 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
Observações
Se especificar ToEven ou AwayFromZero para o mode parâmetro, essas estratégias de arredondamento são aplicadas apenas para valores de ponto médio, ou seja, valores cujo dígito menos significativo é 5.
Ver também
Aplica-se a
Round(Decimal)
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
Arredonda um valor decimal para o número inteiro mais próximo.
public:
static System::Decimal Round(System::Decimal d) = System::Numerics::IFloatingPoint<System::Decimal>::Round;public:
static System::Decimal Round(System::Decimal d);public static decimal Round(decimal d);static member Round : decimal -> decimalPublic Shared Function Round (d As Decimal) As DecimalParâmetros
- d
- Decimal
Um número decimal para arredondar.
Devoluções
O inteiro que está mais próximo do d parâmetro. Se d estiver a meio caminho entre dois inteiros, um dos quais é par e o outro ímpar, o número par é devolvido.
Implementações
Exceções
O resultado está fora do intervalo de um Decimal valor.
Exemplos
O exemplo seguinte arredonda um intervalo de Decimal valores entre 100 e 102 para o número inteiro mais próximo. Como o método utiliza arredondamento bancário, 100,5 rodadas para 100 e 101,5 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 Run()
For value As Decimal = 100D To 102D Step 0.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
Observações
O comportamento deste método segue a Norma IEEE 754, secção 4. Este tipo de arredondamento é por vezes chamado de arredondamento de metade para par ou arredondamento do banqueiro. Minimiza os erros de arredondamento que resultam de arredondar consistentemente um valor do ponto médio numa única direção. É equivalente a chamar o Round(Decimal, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven.
Ver também
Aplica-se a
Round(Decimal, Int32)
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
- Origem:
- Decimal.cs
Arredonda um Decimal valor para um número especificado de casas decimais.
public:
static System::Decimal Round(System::Decimal d, int decimals) = System::Numerics::IFloatingPoint<System::Decimal>::Round;public:
static System::Decimal Round(System::Decimal d, int decimals);public static decimal Round(decimal d, int decimals);static member Round : decimal * int -> decimalPublic Shared Function Round (d As Decimal, decimals As Integer) As DecimalParâmetros
- d
- Decimal
Um número decimal para arredondar.
- decimals
- Int32
Um valor de 0 a 28 que especifica o número de casas decimais a arredondar.
Devoluções
O número decimal equivale a d arredondado para decimals casas decimais.
Implementações
Exceções
decimals não é um valor de 0 a 28.
Exemplos
O exemplo seguinte 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 Example12
Public Sub Run()
' 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
Observações
Este método é equivalente a chamar o Round(Decimal, Int32, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven. Quando d está exatamente a meio caminho entre dois valores arredondados, o resultado é o valor arredondado que tem um dígito par na posição decimal mais à direita. Por exemplo, quando arredondado para dois decimais, o valor 2,345 torna-se 2,34 e o valor 2,355 torna-se 2,36. Este processo é conhecido como arredondamento em direção ao par, ou arredondamento do banqueiro. Minimiza os erros de arredondamento que resultam de arredondar consistentemente um valor do ponto médio numa única direção.
