Decimal.Round Método

Definição

Arredonda um valor para o inteiro ou número especificado de casas decimais mais próximo.Rounds a value to the nearest integer or specified number of decimal places.

Sobrecargas

Round(Decimal)

Arredonda um valor decimal para o inteiro mais próximo.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32)

Arredonda um valor Decimal para um número especificado de casas decimais.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding)

Arredonda um valor decimal para o inteiro mais próximo.Rounds a decimal value to the nearest integer. Um parâmetro especifica como arredondar o valor caso esteja entre dois outros números.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para uma precisão especificada.Rounds a decimal value to a specified precision. Um parâmetro especifica como arredondar o valor caso esteja entre dois outros números.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal)

Arredonda um valor decimal para o inteiro mais próximo.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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to round.

Retornos

O inteiro mais próximo ao parâmetro d.The integer that is nearest to the d parameter. Se d estiver entre dois inteiros, sendo um deles par e outro ímpar, o número par será retornado.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Exceções

O resultado está fora do intervalo de um valor Decimal.The result is outside the range of a Decimal value.

Exemplos

O exemplo a seguir Arredonda um intervalo Decimal de valores entre 100 e 102 para o número inteiro mais próximo.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Como o método usa o arredondamento do Banker, observe que 100,5 arredonda para 100 e 101,5 arredonda para 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

Comentários

O comportamento deste método segue o padrão IEEE 754, seção 4.The behavior of this method follows IEEE Standard 754, section 4. Esse tipo de arredondamento às vezes é chamado de arredondar da metade para o arredondamentopar ou bancário.This kind of rounding is sometimes called round half to even or banker's rounding. Ele minimiza os erros de arredondamento resultantes do arredondamento consistente de um valor de ponto médio em uma única direção.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. É equivalente a chamar o Round(Decimal, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven.It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Veja também

Round(Decimal, Int32)

Arredonda um valor Decimal para um número especificado de casas decimais.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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to round.

decimals
Int32

Um valor de 0 a 28 que especifica o número de casas decimais para o qual arredondar.A value from 0 to 28 that specifies the number of decimal places to round to.

Retornos

O número decimal equivalente ao d arredondado para o número decimals de casas decimais.The decimal number equivalent to d rounded to decimals number of decimal places.

Exceções

decimals não é um valor de 0 a 28.decimals is not a value from 0 to 28.

Exemplos

O exemplo a seguir Arredonda Decimal vários valores para um número especificado de casas decimais usando Round o método.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

Comentários

Esse método é equivalente a chamar o Round(Decimal, Int32, MidpointRounding) método com um mode argumento de MidpointRounding.ToEven. Quando d é exatamente metade entre dois valores arredondados, o resultado é o valor arredondado que tem um dígito par na posição decimal mais à direita.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. 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.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Esse processo é conhecido como arredondamento em direção uniformeou arredondamento do banco.This process is known as rounding toward even, or banker's rounding. Ele minimiza os erros de arredondamento resultantes do arredondamento consistente de um valor de ponto médio em uma única direção.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Veja também

Round(Decimal, MidpointRounding)

Arredonda um valor decimal para o inteiro mais próximo.Rounds a decimal value to the nearest integer. Um parâmetro especifica como arredondar o valor caso esteja entre dois outros números.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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to round.

mode
MidpointRounding

Um valor que especifica como arredondar d caso esteja entre dois outros números.A value that specifies how to round d if it is midway between two other numbers.

Retornos

O inteiro mais próximo ao parâmetro d.The integer that is nearest to the d parameter. Se d estiver entre dois números, sendo um deles par e o outro ímpar, o parâmetro mode determinará qual dos dois será retornado.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.

Exceções

mode não é um valor MidpointRounding.mode is not a MidpointRounding value.

O resultado está fora do intervalo de um objeto Decimal.The result is outside the range of a Decimal object.

Exemplos

O exemplo a seguir exibe valores retornados pelo Round(Decimal) método, o Round(Decimal, MidpointRounding) método com um mode argumento de ToEvene o Round(Decimal, MidpointRounding) método com um mode argumento de 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

Comentários

Em um valor de ponto médio, o valor após o dígito menos significativo no resultado é precisamente meio-caminho entre dois números.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Por exemplo, 7,5 é um valor intermediário se for para ser arredondado para um inteiro.For example, 7.5 is a midpoint value if it is to be rounded to an integer. Para valores de ponto médio, o valor mais próximo não pode ser facilmente identificado sem uma Convenção de arredondamento, mode que é especificada pelo argumento.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. O Round método dá suporte a duas convenções de arredondamento para manipular valores de ponto médio.The Round method supports two rounding conventions for handling midpoint values.

Arredondamento para longe de zero.Rounding away from zero.
Os valores de ponto médio são arredondados para o próximo número distante do zero.Midpoint values are rounded to the next number away from zero. Por exemplo, 3,5 arredonda para 4, 4,5 arredonda para 5,-3,5 arredonda para-4 e-4,5 arredonda para-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Essa forma de arredondamento é representada pelo MidpointRounding.AwayFromZero membro de enumeração.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Arredondar de zero é a forma mais amplamente conhecida de arredondamento.Rounding away from zero is the most widely known form of rounding.

Arredondamento para par ou arredondamento do bancoRounding to even, or banker's rounding
Os valores de ponto médio são arredondados para o número par mais próximo.Midpoint values are rounded to the nearest even number. Por exemplo, 3,5 e 4,5 arredondados para 4 e ambos-3,5 e-4,5 arredondados para-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Essa forma de arredondamento é representada pelo MidpointRounding.ToEven membro de enumeração.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

O arredondamento para mais próximo é a forma padrão de arredondamento usado em operações financeiras e estatísticas.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Ele está de acordo com o IEEE Standard 754, seção 4.It conforms to IEEE Standard 754, section 4. Quando usado em várias operações de arredondamento, ele reduz o erro de arredondamento causado pelo arredondamento consistente de valores de ponto médio em uma única direção.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. Em alguns casos, esse erro de arredondamento pode ser significativo.In some cases, this rounding error can be significant.

Veja também

Round(Decimal, Int32, MidpointRounding)

Arredonda um valor decimal para uma precisão especificada.Rounds a decimal value to a specified precision. Um parâmetro especifica como arredondar o valor caso esteja entre dois outros números.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

Parâmetros

d
Decimal

Um número decimal a ser arredondado.A decimal number to round.

decimals
Int32

O número de casas decimais significativas (precisão) no valor retornado.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

Um valor que especifica como arredondar d caso esteja entre dois outros números.A value that specifies how to round d if it is midway between two other numbers.

Retornos

O número mais próximo do parâmetro d com uma precisão igual ao parâmetro decimals.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Se d estiver entre dois números, sendo um deles par e o outro ímpar, o parâmetro mode determinará qual dos dois será retornado.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. Se a precisão de d for menor que decimals, d será retornado inalterado.If the precision of d is less than decimals, d is returned unchanged.

Exceções

decimals é menor que 0 ou maior que 28.decimals is less than 0 or greater than 28.

mode não é um valor MidpointRounding.mode is not a MidpointRounding value.

O resultado está fora do intervalo de um objeto Decimal.The result is outside the range of a Decimal object.

Exemplos

O exemplo a seguir demonstra como usar o Round(Decimal, Int32, MidpointRounding) método com a MidpointRounding enumeração.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)
'

Comentários

O decimals parâmetro especifica o número de casas decimais significativas no valor de retorno e varia de 0 a 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Se decimals for zero, um inteiro será retornado.If decimals is zero, an integer is returned.

Em um valor de ponto médio, o valor após o dígito menos significativo no resultado é precisamente meio-caminho entre dois números.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Por exemplo, 3,47500 é um valor intermediário se for para ser arredondado duas casas decimais e 7,500 é um valor intermediário se for para ser arredondado para um inteiro.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. Nesses casos, o valor mais próximo não pode ser facilmente identificado sem uma Convenção de arredondamento, que é especificada mode pelo argumento.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. O Round(Decimal, Int32, MidpointRounding) método dá suporte a duas convenções de arredondamento para manipular valores de ponto médio.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Arredondamento para longe de zero.Rounding away from zero.
Os valores de ponto médio são arredondados para o próximo número distante do zero.Midpoint values are rounded to the next number away from zero. Por exemplo, 3,75 arredonda para 3,8, 3,85 arredonda para 3,9,-3,75 arredonda para-3,8 e-3,85 arredonda para-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. Essa forma de arredondamento é representada pelo MidpointRounding.AwayFromZero membro de enumeração.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Arredondar de zero é a forma mais amplamente conhecida de arredondamento.Rounding away from zero is the most widely known form of rounding.

Arredondamento para par ou arredondamento do bancoRounding to even, or banker's rounding
Os valores de ponto médio são arredondados para o número par mais próximo.Midpoint values are rounded to the nearest even number. Por exemplo, 3,75 e 3,85 arredondados para 3,8 e-3,75 e-3,85 Round to-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. Essa forma de arredondamento é representada pelo MidpointRounding.ToEven membro de enumeração.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

O arredondamento para mais próximo é a forma padrão de arredondamento usado em operações financeiras e estatísticas.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Ele está de acordo com o IEEE Standard 754, seção 4.It conforms to IEEE Standard 754, section 4. Quando usado em várias operações de arredondamento, ele reduz o erro de arredondamento causado pelo arredondamento consistente de valores de ponto médio em uma única direção.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. Em alguns casos, esse erro de arredondamento pode ser significativo.In some cases, this rounding error can be significant.

Veja também

Aplica-se a