Decimal.Round Decimal.Round Decimal.Round Decimal.Round Method

Definición

Redondea un valor al entero más próximo o al número especificado de posiciones decimales.Rounds a value to the nearest integer or specified number of decimal places.

Sobrecargas

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Redondea un valor decimal al entero más próximo.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Redondea un valor Decimal a un número especificado de posiciones decimales.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Redondea un valor decimal al entero más próximo.Rounds a decimal value to the nearest integer. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre otros dos números.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Redondea un valor decimal a una precisión especificada.Rounds a decimal value to a specified precision. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre otros dos números.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Redondea un valor decimal al entero más 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 Decimal Decimal Decimal

Número decimal que se va a redondear.A decimal number to round.

Devoluciones

El entero más cercano al parámetro d.The integer that is nearest to the d parameter. Si d se encuentra a la mitad del intervalo entre dos números enteros, uno par y el otro impar, se devuelve el número par.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Excepciones

El resultado está fuera del intervalo de un valor Decimal.The result is outside the range of a Decimal value.

Ejemplos

En el ejemplo siguiente se redondea un Decimal intervalo de valores entre 100 y 102 al entero más cercano.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Dado que el método utiliza el redondeo bancario, tenga en cuenta que 100,5 se redondea a 100 y 101,5 se redondea a 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

Comentarios

El comportamiento de este método sigue el estándar IEEE 754, sección 4.The behavior of this method follows IEEE Standard 754, section 4. Este tipo de redondeo a veces se denomina medio redondo a par o redondeo bancario.This kind of rounding is sometimes called round half to even or banker's rounding. Minimiza los errores de redondeo que son el resultado de redondear de forma coherente un valor de punto medio en una sola dirección.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Es equivalente a llamar al Round(Decimal, MidpointRounding) método con un mode argumento de MidpointRounding.ToEven.It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Consulte también:

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Redondea un valor Decimal a un número especificado de posiciones decimales.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 Decimal Decimal Decimal

Número decimal que se va a redondear.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Valor comprendido entre el 0 y el 28 que especifica el número de posiciones decimales a las que se va a redondear.A value from 0 to 28 that specifies the number of decimal places to round to.

Devoluciones

Número decimal equivalente a d redondeado a un número decimals de posiciones decimales.The decimal number equivalent to d rounded to decimals number of decimal places.

Excepciones

decimals no es un valor comprendido entre 0 y 28.decimals is not a value from 0 to 28.

Ejemplos

En el ejemplo siguiente se Decimal redondean varios valores a un número especificado de posiciones Round decimales mediante el 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

Comentarios

Este método es equivalente a llamar al Round(Decimal, Int32, MidpointRounding) método con un mode argumento de MidpointRounding.ToEven. Cuando d está exactamente a la mitad entre dos valores redondeados, el resultado es el valor redondeado que tiene un dígito par en la posición decimal más a la derecha.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 ejemplo, cuando se redondea a dos decimales, el valor 2,345 se convierte en 2,34 y el valor 2,355 pasa a ser 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Este proceso se conoce como redondeo hacia pareso redondeo bancario.This process is known as rounding toward even, or banker's rounding. Minimiza los errores de redondeo que son el resultado de redondear de forma coherente un valor de punto medio en una sola dirección.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Consulte también:

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Redondea un valor decimal al entero más próximo.Rounds a decimal value to the nearest integer. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre otros dos 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 Decimal Decimal Decimal

Número decimal que se va a redondear.A decimal number to round.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Valor que especifica el redondeo de d si su valor está a la mitad del intervalo entre otros dos números.A value that specifies how to round d if it is midway between two other numbers.

Devoluciones

El entero más cercano al parámetro d.The integer that is nearest to the d parameter. Si d se encuentra a la mitad del intervalo entre dos números, uno par y otro impar, el parámetro mode determina el número que se devuelve.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.

Excepciones

El resultado está fuera del intervalo de un objeto Decimal.The result is outside the range of a Decimal object.

Ejemplos

En el ejemplo siguiente se muestran los valores Round(Decimal) devueltos Round(Decimal, MidpointRounding) por el método mode , el ToEvenmétodo con un Round(Decimal, MidpointRounding) argumento de y mode el método AwayFromZerocon un argumento de.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

Comentarios

En un valor de punto medio, el valor que está después del dígito menos significativo en el resultado es exactamente la mitad de la mitad entre dos números.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Por ejemplo, 7,5 es un valor de punto medio si se va a redondear a un entero.For example, 7.5 is a midpoint value if it is to be rounded to an integer. En el caso de los valores de punto medio, el valor más próximo no se puede identificar fácilmente sin una Convención de mode redondeo, que se especifica mediante el argumento.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. El Round método admite dos convenciones de redondeo para controlar valores de punto medio.The Round method supports two rounding conventions for handling midpoint values.

Redondeo de cero.Rounding away from zero.
Los valores de punto medio se redondean al siguiente número alejándose de cero.Midpoint values are rounded to the next number away from zero. Por ejemplo, 3,5 se redondea a 4, 4,5 se redondea a 5,-3,5 se redondea a-4 y-4,5 se redondea a-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Esta forma de redondeo se representa mediante el miembro MidpointRounding.AwayFromZero de la enumeración.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

El redondeo de cero es la forma más conocida de redondeo.Rounding away from zero is the most widely known form of rounding.

Redondeo a par, o redondeo bancarioRounding to even, or banker's rounding
Los valores de punto medio se redondean al número par más cercano.Midpoint values are rounded to the nearest even number. Por ejemplo, 3,5 y 4,5 se redondean a 4 y-3,5 y-4,5 se redondean a-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Esta forma de redondeo se representa mediante el miembro MidpointRounding.ToEven de la enumeración.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

El redondeo a más cercano es la forma estándar de redondeo que se usa en las operaciones financieras y estadísticas.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Se ajusta al estándar IEEE 754, sección 4.It conforms to IEEE Standard 754, section 4. Cuando se usa en varias operaciones de redondeo, reduce el error de redondeo que se produce al redondear de forma coherente los valores de punto medio en una sola dirección.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. En algunos casos, este error de redondeo puede ser significativo.In some cases, this rounding error can be significant.

Consulte también:

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Redondea un valor decimal a una precisión especificada.Rounds a decimal value to a specified precision. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre otros dos 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 Decimal Decimal Decimal

Número decimal que se va a redondear.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Número de posiciones decimales significativas (precisión) del valor devuelto.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Valor que especifica el redondeo de d si su valor está a la mitad del intervalo entre otros dos números.A value that specifies how to round d if it is midway between two other numbers.

Devoluciones

Número más cercano al parámetro d con una precisión igual al parámetro decimals.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Si d se encuentra a la mitad del intervalo entre dos números, uno par y otro impar, el parámetro mode determina el número que se devuelve.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. Si la precisión de d es menor que decimals, se devuelve d sin modificar.If the precision of d is less than decimals, d is returned unchanged.

Excepciones

decimals es menor que 0 o mayor que 28.decimals is less than 0 or greater than 28.

El resultado está fuera del intervalo de un objeto Decimal.The result is outside the range of a Decimal object.

Ejemplos

En el ejemplo siguiente se muestra cómo utilizar Round(Decimal, Int32, MidpointRounding) el método con MidpointRounding la enumeración.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)
'

Comentarios

El decimals parámetro especifica el número de posiciones decimales significativas en el valor devuelto y oscila entre 0 y 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Si decimals es cero, se devuelve un entero.If decimals is zero, an integer is returned.

En un valor de punto medio, el valor que está después del dígito menos significativo en el resultado es exactamente la mitad de la mitad entre dos números.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Por ejemplo, 3,47500 es un valor de punto medio si se va a redondear dos posiciones decimales y 7,500 es un valor de punto medio si se va a redondear a un entero.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. En estos casos, el valor más cercano no se puede identificar fácilmente sin una Convención de redondeo, que se especifica mode mediante el argumento.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. El Round(Decimal, Int32, MidpointRounding) método admite dos convenciones de redondeo para controlar valores de punto medio.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Redondeo de cero.Rounding away from zero.
Los valores de punto medio se redondean al siguiente número alejándose de cero.Midpoint values are rounded to the next number away from zero. Por ejemplo, 3,75 se redondea a 3,8, 3,85 se redondea a 3,9,-3,75 se redondea a-3,8 y-3,85 se redondea a-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. Esta forma de redondeo se representa mediante el miembro MidpointRounding.AwayFromZero de la enumeración.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

El redondeo de cero es la forma más conocida de redondeo.Rounding away from zero is the most widely known form of rounding.

Redondeo a par, o redondeo bancarioRounding to even, or banker's rounding
Los valores de punto medio se redondean al número par más cercano.Midpoint values are rounded to the nearest even number. Por ejemplo, 3,75 y 3,85 se redondean a 3,8 y a-3,75 y-3,85 se redondean a-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. Esta forma de redondeo se representa mediante el miembro MidpointRounding.ToEven de la enumeración.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

El redondeo a más cercano es la forma estándar de redondeo que se usa en las operaciones financieras y estadísticas.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Se ajusta al estándar IEEE 754, sección 4.It conforms to IEEE Standard 754, section 4. Cuando se usa en varias operaciones de redondeo, reduce el error de redondeo que se produce al redondear de forma coherente los valores de punto medio en una sola dirección.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. En algunos casos, este error de redondeo puede ser significativo.In some cases, this rounding error can be significant.

Consulte también:

Se aplica a