Decimal.Round Método

Definição

Espaço de Nomes:: System

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

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

Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parâ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

Decimal

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

Round(TSelf, Int32, MidpointRounding)

Exceções

ArgumentOutOfRangeException

decimals é inferior a 0 ou superior a 28.

ArgumentException

mode não é um MidpointRounding valor.

OverflowException

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

Round(Decimal, Int32, MidpointRounding)

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

Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parâ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

Decimal

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

Implementações

Round(TSelf, MidpointRounding)

Exceções

ArgumentException

mode não é um MidpointRounding valor.

OverflowException

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

Ver também

Round(Decimal, MidpointRounding)

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

Public Shared Function Round (d As Decimal) As Decimal

Parâmetros

d: Decimal

Um número decimal para arredondar.

Devoluções

Decimal

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

Round(TSelf)

Exceções

OverflowException

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

Round(Decimal)

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

Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parâ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

Decimal

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

Implementações

Round(TSelf, Int32)

Exceções

ArgumentOutOfRangeException

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.

Ver também

Aplica-se a

Comentários

Esta página foi útil?