Math.Round Math.Round Math.Round Math.Round Method

Definición

Redondea un valor al entero más próximo o al número especificado de dígitos fraccionarios.Rounds a value to the nearest integer or to the specified number of fractional digits.

Sobrecargas

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

Redondea un valor decimal a un número especificado de dígitos fraccionarios y usa la convención de redondeo especificada para los valores de punto medio.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y usa la convención de redondeo especificada para los valores de punto medio.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Redondea un valor de punto flotante de precisión doble al entero más cercano y usa la convención de redondeo especificada para los valores de punto medio.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double) Round(Double) Round(Double) Round(Double)

Redondea un valor de punto flotante de precisión doble al valor entero más cercano y los valores de punto medio al número par más cercano.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Redondea un valor decimal a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Redondea un valor decimal al valor entero más cercano y los valores de punto medio al número par más cercano.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Redondea un valor decimal al entero más cercano y usa la convención de redondeo especificada para los valores de punto medio.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Ejemplos

Además de los ejemplos en los comentarios sección, este artículo incluyen ejemplos que ilustran las sobrecargas siguientes de la Math.Round método:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

Math.Round(Decimal)Math.Round(Decimal)
Math.Round(Double)Math.Round(Double)
Math.Round(Decimal, Int32)Math.Round(Decimal, Int32)
Math.Round(Decimal, MidpointRounding)Math.Round(Decimal, MidpointRounding)
Math.Round(Double, Int32)Math.Round(Double, Int32)
Math.Round(Double, MidpointRounding)Math.Round(Double, MidpointRounding)
Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Double, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Nota

Los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva.Select the Run button to run an example in an interactive window. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar.Once you execute the code, you can modify it and run the modified code by selecting Run again. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Comentarios

En esta sección:In this section:

¿Qué método se debe llamar?Which method do I call?

Puede usar la siguiente tabla para seleccionar un método adecuado de redondeo.You can use the following table to select an appropriate rounding method. Además el Math.Round métodos, también incluye Math.Ceiling y Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

EnTo CallCall
Redondear un número en un entero utilizando el redondeo al más cercano convención.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

O bien-or-

Round(Double)
Un número en un entero mediante el uso de un determinado de ida y vuelta de redondeo convención.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

O bien-or-

Round(Double, MidpointRounding)
Redondear un número a un número especificado de dígitos fraccionarios utilizando el redondeo al más cercano convención.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

O bien-or-

Round(Double, Int32)
Redondear un número a un número especificado de dígitos fraccionarios utilizando un redondeo convención.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

O bien-or-

Round(Double, Int32, MidpointRounding)
Redondear un Single valor a un número especificado de dígitos fraccionarios mediante una convención de redondeo especificado y minimizar la pérdida de precisión.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Convertir el Single a un Decimal y llamar a Round(Decimal, Int32, MidpointRounding).Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Redondear un número a un número especificado de dígitos fraccionarios mientras se minimizan los problemas de precisión en los valores de punto medio de redondeo.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Llamar a un método de redondeo que implementa una comparación "mayor o aproximadamente igual a".Call a rounding method that implements a "greater than or approximately equal to" comparison. Consulte redondeo y la precisión.See Rounding and precision.
Redondear un valor fraccionario en un entero que es mayor que el valor de fracciones.Round a fractional value to an integer that is greater than the fractional value. Por ejemplo, redondear 3.1 a 4.For example, round 3.1 to 4. Ceiling
Redondear un valor fraccionario en un entero que es menor que el valor de fracciones.Round a fractional value to an integer that is less than the fractional value. Por ejemplo, redondear 3.9 a 3.For example, round 3.9 to 3. Floor

Los valores de punto medio y convenciones de redondeoMidpoint values and rounding conventions

Redondeo implica convertir un valor numérico con una precisión especificada con precisión inferior al valor más cercano.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Por ejemplo, puede usar el Round(Double) método para redondear un valor de 3.4 a 3.0 y el Round(Double, Int32) método para redondear un valor de 3,579 a 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

En un valor de punto medio, el valor después de los dígitos menos significativos en el resultado es precisamente mitad de camino 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 van a ser redondea a dos posiciones decimales y 7.500 es un valor de punto medio si se van a se redondea 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 puede identificarse fácilmente sin una convención de redondeo.In these cases, the nearest value can't be easily identified without a rounding convention.

El Round método es compatible con dos convenciones de redondeo para controlar los valores de punto medio:The Round method supports two rounding conventions for handling midpoint values:

  • Redondeo para evitar el ceroRounding away from zero

    Los valores de punto medio se redondean al siguiente número de dirección contraria a cero.Midpoint values are rounded to the next number away from zero. Por ejemplo, se redondea 3,75 a 3.8, 3.85 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 MidpointRounding.AwayFromZero miembro de enumeración.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    Redondeo para evitar el cero es la forma más ampliamente conocida de redondeo.Rounding away from zero is the most widely known form of rounding.

  • Redondeo al más próximo o redondeo bancarioRounding to nearest, 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 redondear 3.8 y redondean-3.8-3.75 y-3.85.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 MidpointRounding.ToEven miembro de enumeración.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    Redondeo al más próximo es la forma estándar de redondeo utilizado 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 sistemáticamente redondeando los valores de punto medio en un solo sentido.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.

    El ejemplo siguiente ilustra la diferencia que puede obtenerse al redondeo constantemente los valores de punto medio en un solo sentido.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. El ejemplo calcula la media real de una matriz de Decimal valores y, a continuación, calcula la media cuando se redondean los valores de la matriz mediante las convenciones de dos.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. En este ejemplo, la verdadera Media y la media de la que se produce cuando el redondeo al más próximo son los mismos.In this example, the true mean and the mean that results when rounding to nearest are the same. Sin embargo, la media de la que se produce cuando el redondeo para evitar el cero difiere.05 (o 3,6%) desde el promedio es true.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
    decimal sum = 0;
    
    // Calculate true mean.
    foreach (var value in values)
       sum += value;
    
    Console.WriteLine("True mean:     {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding away from zero.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
    
    Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding to nearest.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.ToEven);
    
    Console.WriteLine("ToEven:        {0:N2}", sum/values.Length);
    // The example displays the following output:
    //       True mean:     1.40
    //       AwayFromZero:  1.45
    //       ToEven:        1.40
    
    Module Example
       Public Sub Main()
          Dim values() As Decimal = { 1.15d, 1.25d, 1.35d, 1.45d, 1.55d, 1.65d }
          Dim sum As Decimal
          
          ' Calculate true mean.
          For Each value In values
             sum += value
          Next
          Console.WriteLine("True mean:     {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding away from zero.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
          Next
          Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding to nearest.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.ToEven)
          Next
          Console.WriteLine("ToEven:        {0:N2}", sum/values.Length)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

De forma predeterminada, el Round método utiliza el redondeo al más cercano convención.By default, the Round method uses the rounding to nearest convention. En la tabla siguiente se enumera las sobrecargas de los Round método y la convención de redondeo que se usa cada uno.The following table lists the overloads of the Round method and the rounding convention that each uses.

SobrecargaOverload Convención de redondeoRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Determinado por mode parámetro.Determined by mode parameter.
Round(Double, MidpointRounding) Determinado por mode parámetroDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Determinado por mode parámetroDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Determinado por mode parámetroDetermined by mode parameter

Redondeo y la precisiónRounding and precision

Con el fin de determinar si una operación de redondeo implica un valor de punto medio, el Round método multiplica el valor original se redondea por 10n, donde n es el número deseado de fraccionarios dígitos del valor devuelto y, a continuación, determina si la parte fraccionaria restante del valor es mayor o igual que.5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Se trata de una ligera variación en una prueba de igualdad y, como hemos explicado en la sección "Prueba de igualdad" de la Double tema de referencia, comprueba la igualdad con valores de punto flotante es problemática debido a problemas de formato de punto flotante con binario representación y la precisión.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. Esto significa que cualquier parte fraccionaria de un número que es ligeramente menor que.5 (debido a una pérdida de precisión) no se redondeará hacia arriba.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

En el siguiente ejemplo se ilustra el problema.The following example illustrates the problem. Repetidamente agrega.1 a 11.0 y redondea el resultado al entero más próximo.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Independientemente de la convención de redondeo, 11.5 deben redondear al 12.Regardless of the rounding convention, 11.5 should round to 12. Sin embargo, como la salida se muestra en el ejemplo, no la tiene.However, as the output from the example shows, it does not. El ejemplo utiliza la "R" cadena de formato numérico estándar para mostrar el punto flotante del valor precisión completa y muestra que el valor se redondee ha perdido precisión durante repetidas adiciones, y su valor es realmente 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Dado que.499999999999998 es menor que.5, el valor no se redondea al entero superior siguiente.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Como se muestra también en el ejemplo, este problema no ocurre si simplemente asignamos el valor constante 11.5 a un Double variable.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero");
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)    
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }
   
   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//       
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//       
//        11.5                 11.5            12              12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1

      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero")
      Console.WriteLine()
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Problemas de precisión en los valores de punto medio de redondeo están más probables que surgen en las siguientes condiciones:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • Cuando un valor fraccionario se no se puede expresar con precisión en formato binario del tipo de punto flotante.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • Cuando se calcula el valor se redondea desde uno o más operaciones de punto flotante.When the value to be rounded is calculated from one or more floating-point operations.

  • Cuando el valor se redondea es un Single en lugar de un Double o Decimal.When the value to be rounded is a Single rather than a Double or Decimal. Para obtener más información, consulte la sección siguiente, redondear y valores de punto flotante de precisión sencilla.For more information, see the next section, Rounding and single-precision floating-point values.

En casos donde la falta de precisión en las operaciones de redondeo es problemática, puede hacer lo siguiente:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Si la operación de redondeo llama a una sobrecarga que se redondea un Double valor, puede cambiar el Double a un Decimal de valor y llamar a una sobrecarga que redondea un Decimal valor en su lugar.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. Aunque el Decimal también tiene el tipo de datos de problemas de representación y la pérdida de precisión, estos problemas son mucho menos comunes.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Definir un algoritmo personalizado de redondeo que se realiza una prueba para determinar si el valor se redondea es aceptablemente cerca de un valor de punto medio "casi igual".Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. En el ejemplo siguiente se define un RoundApproximate método que busca para determinar si un valor fraccionario es lo suficientemente cerca de un valor de punto medio para estar sujeto a redondeo de punto medio.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Como se muestra el resultado del ejemplo, corrige el problema de redondeo que se muestra en el ejemplo anterior.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero");
          double value = 11.1;
          for (int ctr = 0; ctr <= 5; ctr++)    
             value = RoundValueAndAdd(value);
    
          Console.WriteLine();
    
          value = 11.5;
          RoundValueAndAdd(value);
       }
       
       private static double RoundValueAndAdd(double value)
       {
          const double tolerance = 8e-14;
    
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
          return value + .1;
       }
    
       private static double RoundApproximate(double dbl, int digits, double margin, 
                                         MidpointRounding mode)
       {                                      
          double fraction = dbl * Math.Pow(10, digits);
          double value = Math.Truncate(fraction); 
          fraction = fraction - value;   
          if (fraction == 0)
             return dbl;
          
          double tolerance = margin * dbl;
          // Determine whether this is a midpoint value.
          if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance)) {
             if (mode == MidpointRounding.AwayFromZero)
                return (value + 1)/Math.Pow(10, digits);
             else
                if (value % 2 != 0)
                   return (value + 1)/Math.Pow(10, digits);
                else
                   return value/Math.Pow(10, digits);
          }
          // Any remaining fractional value greater than .5 is not a midpoint value.
          if (fraction > .5)
             return (value + 1)/Math.Pow(10, digits);
          else
             return value/Math.Pow(10, digits);
       }
    }
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //       
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //       
    //        11.5                 11.5            12              12
    
    Module Example
       Public Sub Main()
          Dim value As Double = 11.1
    
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero")
          For ctr As Integer = 0 To 5    
             value = RoundValueAndAdd(value)
          Next
          Console.WriteLine()
    
          value = 11.5
          RoundValueAndAdd(value)
       End Sub
       
       Private Function RoundValueAndAdd(value As Double) As Double
          Const tolerance As Double = 8e-14
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
          Return value + .1
       End Function   
    
       Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double, 
                                         mode As MidpointRounding) As Double
          Dim fraction As Double = dbl * Math.Pow(10, digits)
          Dim value As Double = Math.Truncate(fraction) 
          fraction = fraction - value   
          If fraction = 0 Then Return dbl
          
          Dim tolerance As Double = margin * dbl
          ' Determine whether this is a midpoint value.
          If (fraction >= .5 - tolerance) And (fraction <= .5 + tolerance) Then
             If mode = MidpointRounding.AwayFromZero Then
                Return (value + 1)/Math.Pow(10, digits)
             Else
                If value Mod 2 <> 0 Then
                   Return (value + 1)/Math.Pow(10, digits)
                Else
                   Return value/Math.Pow(10, digits)
                End If
             End If
          End If
          ' Any remaining fractional value greater than .5 is not a midpoint value.
          If fraction > .5 Then
             Return (value + 1)/Math.Pow(10, digits)
          Else
             return value/Math.Pow(10, digits)
          End If      
       End Function
    End Module
    ' The example displays the following output:
    '       Value       Full Precision        ToEven    AwayFromZero
    '       
    '        11.1                 11.1            11              11
    '        11.2                 11.2            11              11
    '        11.3   11.299999999999999            11              11
    '        11.4   11.399999999999999            11              11
    '        11.5   11.499999999999998            12              12
    '        11.6   11.599999999999998            12              12
    '       
    '        11.5                 11.5            12              12
    

Valores de punto flotante de precisión sencilla y redondeoRounding and single-precision floating-point values

El Round método incluye sobrecargas que aceptan argumentos de tipo Decimal y Double.The Round method includes overloads that accept arguments of type Decimal and Double. No existen métodos que los valores de tipo de ida y vuelta Single.There are no methods that round values of type Single. Si se pasa un Single valor a una de las sobrecargas de la Round método, se convierta (en C#) o convertir (en Visual Basic) a un Doubley la correspondiente Round sobrecarga con un Double parámetro se denomina.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Aunque se trata de una conversión de ampliación, a menudo implica una pérdida de precisión, como se muestra en el ejemplo siguiente.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Cuando un Single 16.325 valor se pasa a la Round método y se redondean a dos posiciones decimales mediante el redondeo al más cercano convención, el resultado es el resultado de 16.33 y no esperado de 16.32.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 16.325f;
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, (double) value, 
                        ((double) (value)).GetType().Name);
      Console.WriteLine(Math.Round(value, 2));
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
      Console.WriteLine();
      
      Decimal decValue = (decimal) value;
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name);
      Console.WriteLine(Math.Round(decValue, 2));
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//    
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
Module Example
   Public Sub Main()
      Dim value As Single = 16.325
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, CDbl(value), 
                        CDbl(value).GetType().Name)
      Console.WriteLine(Math.Round(value, 2))
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
      
      Dim decValue As Decimal = CDec(value)
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name)
      Console.WriteLine(Math.Round(decValue, 2))
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Este resultado inesperado es debido a una pérdida de precisión en la conversión de la Single valor a un Double.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Dado que resultante Double valor de 16.325000762939453 no es un valor de punto medio y es mayor que 16.325, siempre se redondea hacia arriba.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

En muchos casos, como se muestra en el ejemplo siguiente, la pérdida de precisión puede minimizarse o eliminar mediante la conversión del Single valor a un Decimal.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Tenga en cuenta que, como se trata de una conversión de restricción, requiere utilizando un operador de conversión o llamar a un método de conversión.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

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

Redondea un valor decimal a un número especificado de dígitos fraccionarios y usa la convención de redondeo especificada para los valores de punto medio.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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 be rounded.

decimals
Int32 Int32 Int32 Int32

Número de posiciones decimales del valor devuelto.The number of decimal places in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Especificación sobre el redondeo de d si se encuentra a la mitad del intervalo comprendido entre otros dos números.Specification for how to round d if it is midway between two other numbers.

Devoluciones

Número más cercano a d que contiene varios dígitos fraccionarios iguales a decimals.The number nearest to d that contains a number of fractional digits equal to decimals. Si d tiene menos dígitos fraccionarios que decimals, d se devuelve sin modificar.If d has fewer fractional digits 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.

mode no es un valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

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

Comentarios

Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

El valor de la decimals argumento puede oscilar entre 0 y 28.The value of the decimals argument can range from 0 to 28.

EjemploExample

En el ejemplo siguiente se muestra cómo usar el Round método con el MidpointRounding enumeración.The following example demonstrates how to use the Round 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.
Imports System

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 'Main
End Class 'Sample
'
'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)
'
Consulte también:

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y usa la convención de redondeo especificada para los valores de punto medio.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, int digits, MidpointRounding mode);
public static double Round (double value, int digits, MidpointRounding mode);
static member Round : double * int * MidpointRounding -> double
Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parámetros

value
Double Double Double Double

Número de punto flotante de precisión doble que se va a redondear.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Número de dígitos fraccionarios del valor devuelto.The number of fractional digits in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Especificación sobre el redondeo de value si se encuentra a la mitad del intervalo comprendido entre otros dos números.Specification for how to round value if it is midway between two other numbers.

Devoluciones

Número más cercano a value que tiene varios dígitos fraccionarios iguales a digits.The number nearest to value that has a number of fractional digits equal to digits. Si value tiene menos dígitos fraccionarios que digits, value se devuelve sin modificar.If value has fewer fractional digits than digits, value is returned unchanged.

Excepciones

digits es menor que 0 o mayor que 15.digits is less than 0 or greater than 15.

mode no es un valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

Comentarios

El valor de la digits argumento puede oscilar entre 0 y 15.The value of the digits argument can range from 0 to 15. Tenga en cuenta que 15 es el número máximo de dígitos enteros y fraccionarios admitidos por el Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

Si el valor de la value argumento es Double.NaN, el método devuelve Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EjemploExample

En el ejemplo siguiente se muestra cómo usar el Round(Double, Int32, MidpointRounding) método con el MidpointRounding enumeración.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default. 
 double 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)\n", result, negValue);

 // Round a positive value using a MidpointRounding value. 
 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)\n", 
                   result, posValue);

 // Round a negative value using a MidpointRounding value. 
 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)\n", 
                   result, negValue);
// The example displays the following output:
//        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)
Module Example
    Public Sub Main() 
        Dim posValue As Double = 3.45
        Dim negValue As Double = -3.45
        
        ' Round a positive and a negative value using the default.  
        Dim result As Double = 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 using a MidpointRounding value. 
        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 positive value using a MidpointRounding value. 
        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 Module
' The example displays the following output:
'       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)

Notas a los autores de las llamadas

Debido a la pérdida de precisión que puede obtenerse al que representa los valores decimales como números de punto flotante o efectuar operaciones aritméticas en valores de punto flotante, en algunos casos el Round(Double, Int32, MidpointRounding) no puede aparecer el método redondear los valores de punto medio tal como se especifica por el mode parámetro.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. Esto se muestra en el ejemplo siguiente, donde se redondea 2.135 2.13 en lugar de 2.14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Esto ocurre porque internamente el método multiplica value por 10dígitos, y la operación de multiplicación en este caso sufre una pérdida de precisión.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

Consulte también:

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Redondea un valor de punto flotante de precisión doble al entero más cercano y usa la convención de redondeo especificada para los valores de punto medio.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, MidpointRounding mode);
public static double Round (double value, MidpointRounding mode);
static member Round : double * MidpointRounding -> double
Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parámetros

value
Double Double Double Double

Número de punto flotante de precisión doble que se va a redondear.A double-precision floating-point number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Especificación sobre el redondeo de value si se encuentra a la mitad del intervalo comprendido entre otros dos números.Specification for how to round value if it is midway between two other numbers.

Devoluciones

value entero más cercano.The integer nearest value. Si value se encuentra a la mitad del intervalo entre dos enteros, uno par y el otro impar, mode determina los dos números que se devuelven.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Tenga en cuenta que este método devuelve un valor Double en lugar de un tipo entero.Note that this method returns a Double instead of an integral type.

Excepciones

mode no es un valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

Comentarios

Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

Si el valor de la value argumento es Double.NaN, el método devuelve Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EjemploExample

El ejemplo siguiente muestra los valores devueltos por la Round(Double) método, el Round(Double, MidpointRounding) método con un mode argumento de ToEveny el Round(Double, MidpointRounding) método con un mode argumento de AwayFromZero.The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                          12.7, 12.8, 12.9, 13.0 };
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {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()
      Dim values() As Double = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                                 12.7, 12.8, 12.9, 13.0 }
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         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

Notas a los autores de las llamadas

Debido a la pérdida de precisión que puede obtenerse al que representa los valores decimales como números de punto flotante o efectuar operaciones aritméticas en valores de punto flotante, en algunos casos el Round(Double, MidpointRounding) no puede aparecer el método redondear los valores de punto medio en el entero par más próximo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. En el ejemplo siguiente, ya que el valor de punto flotante.1 ninguna representación binaria finita, la primera llamada a la Round(Double) método con un valor de 11.5 devuelve 11 en lugar de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4][!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4]

Consulte también:

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

public:
 static double Round(double value, int digits);
public static double Round (double value, int digits);
static member Round : double * int -> double
Public Shared Function Round (value As Double, digits As Integer) As Double

Parámetros

value
Double Double Double Double

Número de punto flotante de precisión doble que se va a redondear.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Número de dígitos fraccionarios del valor devuelto.The number of fractional digits in the return value.

Devoluciones

Número más cercano a value que contiene varios dígitos fraccionarios iguales a digits.The number nearest to value that contains a number of fractional digits equal to digits.

Excepciones

digits es menor que 0 o mayor que 15.digits is less than 0 or greater than 15.

Comentarios

El valor de la digits argumento puede oscilar entre 0 y 15.The value of the digits argument can range from 0 to 15. Tenga en cuenta que 15 es el número máximo de dígitos enteros y fraccionarios admitidos por el Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Este método utiliza la convención de redondeo predeterminado MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

Si el valor de la value argumento es Double.NaN, el método devuelve Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EjemploExample

En el ejemplo siguiente se redondea los valores double con dos dígitos fraccionarios en dobles que tienen un único dígito fraccionario.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Notas a los autores de las llamadas

Debido a la pérdida de precisión que puede obtenerse al que representa los valores decimales como números de punto flotante o efectuar operaciones aritméticas en valores de punto flotante, en algunos casos el Round(Double, Int32) no puede aparecer el método redondear los valores de punto medio en el más próximo al valor incluso en la digits posición decimal.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. Esto se muestra en el ejemplo siguiente, donde se redondea 2.135 2.13 en lugar de 2.14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Esto ocurre porque internamente el método multiplica value por 10dígitos, y la operación de multiplicación en este caso sufre una pérdida de precisión.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2][!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2]

Consulte también:

Round(Double) Round(Double) Round(Double) Round(Double)

Redondea un valor de punto flotante de precisión doble al valor entero más cercano y los valores de punto medio al número par más cercano.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

public:
 static double Round(double a);
public static double Round (double a);
static member Round : double -> double
Public Shared Function Round (a As Double) As Double

Parámetros

a
Double Double Double Double

Número de punto flotante de precisión doble que se va a redondear.A double-precision floating-point number to be rounded.

Devoluciones

a entero más cercano.The integer nearest a. Si el componente fraccionario de a se encuentra en medio del intervalo entre dos números, uno par y el otro impar, se devuelve el número impar.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Tenga en cuenta que este método devuelve un valor Double en lugar de un tipo entero.Note that this method returns a Double instead of an integral type.

Comentarios

Este método utiliza la convención de redondeo predeterminado MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

Si el valor de la a argumento es Double.NaN, el método devuelve Double.NaN.If the value of the a argument is Double.NaN, the method returns Double.NaN. Si a es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

A partir de Visual Basic 15,8, se optimiza el rendimiento de la conversión de doble al entero si se pasa el valor devuelto por la Round método a cualquiera de los funciones de conversión de enteros, o si el valor de tipo Double devuelto por Round se convierte automáticamente en un entero con Option Strict se establece en desactivado.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. Esta optimización permite que el código se ejecute más rápido, hasta el doble de rápido para código que realiza un gran número de conversiones a tipos enteros.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. El ejemplo siguiente muestra estas conversiones optimizadas:The following example illustrates such optimized conversions:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

EjemploExample

El ejemplo siguiente muestra el redondeo al valor entero más cercano.The following example demonstrates rounding to the nearest integer value.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}
Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6
Imports System

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Notas a los autores de las llamadas

Debido a la pérdida de precisión que puede obtenerse al que representa los valores decimales como números de punto flotante o efectuar operaciones aritméticas en valores de punto flotante, en algunos casos el Round(Double) no puede aparecer el método redondear los valores de punto medio en el entero par más próximo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. En el ejemplo siguiente, ya que el valor de punto flotante.1 ninguna representación binaria finita, la primera llamada a la Round(Double) método con un valor de 11.5 devuelve 11 en lugar de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1][!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1]

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 dígitos fraccionarios y los valores de punto medio al número par más cercano.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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 be rounded.

decimals
Int32 Int32 Int32 Int32

Número de posiciones decimales del valor devuelto.The number of decimal places in the return value.

Devoluciones

Número más cercano a d que contiene varios dígitos fraccionarios iguales a decimals.The number nearest to d that contains a number of fractional digits equal to decimals.

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 Decimal.The result is outside the range of a Decimal.

Comentarios

El valor de la decimals argumento puede oscilar entre 0 y 28.The value of the decimals argument can range from 0 to 28.

Este método utiliza la convención de redondeo predeterminado MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

EjemploExample

El ejemplo siguiente redondea los valores decimales con dos dígitos fraccionarios que los valores que tienen un único dígito fraccionario.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

Console.WriteLine(Math.Round(3.44m, 1)); 
Console.WriteLine(Math.Round(3.45m, 1)); 
Console.WriteLine(Math.Round(3.46m, 1)); 
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1)); 
Console.WriteLine(Math.Round(4.35m, 1)); 
Console.WriteLine(Math.Round(4.36m, 1)); 
// The example displays the following output:
//       3.4
//       3.4
//       3.5
//       
//       4.3
//       4.4
//       4.4
Public Module Example
   Sub Main()
      Console.WriteLine(Math.Round(3.44, 1)) 
      Console.WriteLine(Math.Round(3.45, 1)) 
      Console.WriteLine(Math.Round(3.46, 1)) 
      Console.WriteLine()
      
      Console.WriteLine(Math.Round(4.34, 1)) 
      Console.WriteLine(Math.Round(4.35, 1)) 
      Console.WriteLine(Math.Round(4.36, 1)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4
Consulte también:

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

Redondea un valor decimal al valor entero más cercano y los valores de punto medio al número par más cercano.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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 be rounded.

Devoluciones

El entero más cercano al parámetro d.The integer nearest the d parameter. Si el componente fraccionario de d se encuentra en medio del intervalo entre dos números, uno par y el otro impar, se devuelve el número impar.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Tenga en cuenta que este método devuelve un valor Decimal en lugar de un tipo entero.Note that this method returns a Decimal instead of an integral type.

Excepciones

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

Comentarios

Este método utiliza la convención de redondeo predeterminado MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

EjemploExample

En el ejemplo siguiente se muestra el Round(Decimal) método.The following example demonstrates the Round(Decimal) method. Tenga en cuenta que el Decimal valor 4,5 se redondea a 4 en lugar de 5, porque esta sobrecarga utiliza el valor predeterminado ToEven convención.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5
Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5
Consulte también:

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

Redondea un valor decimal al entero más cercano y usa la convención de redondeo especificada para los valores de punto medio.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

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 be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Especificación sobre el redondeo de d si se encuentra a la mitad del intervalo comprendido entre otros dos números.Specification for how to round d if it is midway between two other numbers.

Devoluciones

d entero más cercano.The integer nearest d. Si d se encuentra a la mitad del intervalo entre dos números, uno par y el otro impar, mode determina los dos números que se devuelven.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. Tenga en cuenta que este método devuelve un valor Decimal en lugar de un tipo entero.Note that this method returns a Decimal instead of an integral type.

Excepciones

mode no es un valor válido de MidpointRounding.mode is not a valid value of MidpointRounding.

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

Comentarios

Consulte los valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad.When rounding midpoint values, the rounding algorithm performs an equality test. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Para más información, consulte "Redondeo y la precisión".For more information, see "Rounding and precision".

EjemploExample

El ejemplo siguiente muestra los valores devueltos por la Round(Decimal) método, el Round(Decimal, MidpointRounding) método con un mode argumento de ToEveny el Round(Decimal, MidpointRounding) método con un 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
Consulte también:

Se aplica a