Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Math.Round

 

Publicado: octubre de 2016

Redondea un valor al entero más próximo o al número especificado de dígitos fraccionarios.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal)

Redondea un valor decimal al valor integral más próximo.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32)

Redondea un valor decimal al número especificado de dígitos fraccionarios.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32, MidpointRounding)

Redondea un valor decimal al número especificado de dígitos fraccionarios. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre dos números.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, MidpointRounding)

Redondea un valor decimal al entero más próximo. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre dos números.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double)

Redondea un valor de punto flotante de precisión doble al valor integral más cercano.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32)

Redondea un valor de punto flotante de precisión doble al número especificado de dígitos fraccionarios.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32, MidpointRounding)

Redondea un valor de punto flotante de precisión doble al número especificado de dígitos fraccionarios. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre dos números.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, MidpointRounding)

Redondea un valor de punto flotante de precisión doble al entero más cercano. Un parámetro especifica el redondeo del valor si está a la mitad del intervalo entre dos números.

Para obtener orientación adicional acerca de cómo elegir una sobrecarga, consulte qué método se debe llamar?

Decimal Math.Round(Decimald)

Redondea un valor decimal al entero más cercano y redondea los valores de punto medio al número par más cercano (ejemplo).

Double Math.Round(Doublea)

Redondea un valor de punto flotante de precisión doble al entero más cercano y redondea los valores de punto medio al número par más cercano (ejemplo).

Decimal Math.Round(Decimald, Int32 decimals)

Redondea un valor decimal al número especificado de dígitos fraccionarios y redondea los valores de punto medio al número par más cercano (ejemplo).

Double Math.Round(Doublevalue, Int32 digits)

Redondea un valor de punto flotante de precisión doble al número especificado de dígitos fraccionarios y redondea los valores de punto medio al número par más cercano (ejemplo).

Decimal Math.Round(Decimald, MidpointRounding mode)

Redondea un valor decimal al entero más próximo y utiliza la convención de redondeo especificada para los valores de punto medio (ejemplo).

Double Math.Round(Doublevalue, MidpointRounding mode)

Redondea un valor de punto flotante de precisión doble al entero más próximo y utiliza la convención de redondeo especificada para los valores de punto medio (ejemplo).

Decimal Math.Round(Decimald, Int32 decimals, MidpointRounding mode)

Redondea un valor decimal al número especificado de dígitos fraccionarios y utiliza la convención de redondeo especificada para los valores de punto medio (ejemplo).

Double Math.Round(Doublevalue, Int32 digits, MidpointRounding mode)

Redondea un valor de punto flotante de precisión doble al número especificado de dígitos fraccionarios y utiliza la convención de redondeo especificada para los valores de punto medio (ejemplo).

Se trata de una lista completa de parámetros para el Round (método). Para los parámetros utilizados por cada sobrecarga, vea la sintaxis de sobrecarga anterior.

Parámetro

Tipo

Descripción

d

Decimal

Un número que se va a redondear.

a

O bien

value

Double

Número de punto flotante de precisión doble que se va a redondear.

decimals

O bien

digits

Int32

Número de dígitos fraccionarios del valor devuelto. Para Decimal valores, puede oscilar entre 0 y el 28. Para Double valores, puede oscilar entre 0 y 15. Tenga en cuenta que 15 es el número máximo de dígitos enteros y fraccionarios admitidos por el Double tipo.

Valor predeterminado: 0, que se redondea a un entero

mode

MidpointRounding

Una marca que especifica la convención que se utilizará para redondear los valores de punto medio. Consulte valores de punto medio y convenciones de redondeo.

Valor predeterminado: MidpointRounding.ToEven

Tipo: Decimal o Double, según el tipo del valor que se va a redondear.
Un valor numérico del mismo tipo como d, a, o value, pero redondeado a un entero o al número especificado de dígitos decimales.
Consulte valores de punto medio y convenciones de redondeo para obtener información sobre el redondeo de números con valores de punto medio.

System_CAPS_warningAdvertencia

Cuando se redondea los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y la precisión en el formato de punto flotante, el valor devuelto por el método puede ser inesperado. Para obtener más información, consulte redondeo y la precisión.

Si una sobrecarga con un Double parámetro se denomina con Double.NaN, el método devuelve Double.NaN. Si se llama con Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.

Para

Llame a

Redondear un número en un entero utilizando el redondeo al más cercano convención.

Round(Decimal)

O bien

Round(Double)

Redondea un número en un entero utilizando una convención de redondeo.

Round(Decimal, MidpointRounding)

O bien

Round(Double, MidpointRounding)

Redondear un número al número especificado de dígitos fraccionarios utilizando el redondeo al más cercano convención.

Round(Decimal, Int32)

O bien

Round(Double, Int32)

Redondea un número al número especificado de dígitos fraccionarios utilizando una convención de redondeo.

Round(Decimal, Int32, MidpointRounding)

O bien

Round(Double, Int32, MidpointRounding)

Redondear un Single valor a un número especificado de dígitos fraccionarios utilizando una convención de redondeo especificada y minimizar la pérdida de precisión.

Convertir el Single a una Decimal y llame a Round(Decimal, Int32, MidpointRounding).

Redondear un número al número especificado de dígitos fraccionarios mientras se minimizan los problemas de precisión de redondeo de los valores de punto medio.

Llamar a un método de redondeo que implementa una comparación "mayor o aproximadamente igual a". Consulte redondeo y la precisión.

Redondea un valor fraccionario en un entero que es mayor que el valor de fracciones. Por ejemplo, redondear 3.1 a 4.

Ceiling

Redondea un valor fraccionario en un entero que es menor que el valor de fracciones. Por ejemplo, redondear 3.9 a 3.

Floor

Redondeo implica convertir un valor numérico con una precisión especificada al valor más cercano con menor precisión. Por ejemplo, puede usar el Round(Double) método 3.4 a 3.0, el valor de redondeo y la Round(Double, Int32) método para redondear un valor de 3,579 a 3,58.

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. Por ejemplo, 3.47500 es un valor de punto medio si no redondea a dos posiciones decimales y 7.500 es un valor de punto medio si no se redondea a un entero. En estos casos, el valor más cercano no se puede identificar fácilmente sin una convención de redondeo.

El Round método es compatible con dos convenciones de redondeo para controlar los valores de punto medio:

Redondeo para evitar el cero

Los valores de punto medio se redondean al siguiente número de dirección contraria a cero. Por ejemplo, se redondea 3,75 a 3.8, 3.85 redondea al 3.9,-3.75 se redondea a-3.8, y-3.85 se redondea a-3.9. Este formulario de redondeo se representa mediante el MidpointRounding.AwayFromZero miembro de enumeración.

Redondeo para evitar el cero es la forma más conocida de redondeo.

Redondeo al más próximo o redondeo bancario

Los valores de punto medio se redondean al número par más cercano. Por ejemplo, redondear 3.8 3,75 y 3.85 y-3.75 y-3.85 se redondean a-3.8. Este formulario de redondeo se representa mediante el MidpointRounding.ToEven miembro de enumeración.

Redondeo al más próximo es la forma estándar de redondeo utilizado en las operaciones financieras y estadísticas. Se ajusta al estándar IEEE 754, sección 4. Cuando se utiliza en varias operaciones de redondeo, reduce el error de redondeo que se debe a los valores de punto medio en una dirección única de redondear de forma consistente. En algunos casos, este error de redondeo puede ser significativo.

En el ejemplo siguiente se muestra la diferencia que puede derivarse de redondear de forma consistente los valores de punto medio en una dirección única. En el ejemplo se calcula la media de una matriz de true Decimal valores y, a continuación, calcula la media cuando los valores de la matriz se redondean usando las convenciones de dos. 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. Sin embargo, la media de la que se produce cuando el redondeo para evitar el cero difiere 05 (o 3,6%) de la media es true.

using System;

public class Example
{
   public static void Main()
   {
      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

De forma predeterminada, la Round método utiliza el redondeo al más cercano convención. La tabla siguiente enumeran las sobrecargas de los Round método y la convención de redondeo que utiliza cada uno.

Sobrecarga

Convención de redondeo

Round(Decimal)

ToEven

Round(Double)

ToEven

Round(Decimal, Int32)

ToEven

Round(Double, Int32)

ToEven

Round(Decimal, MidpointRounding)

Determinado por mode parámetro.

Round(Double, MidpointRounding)

Determinado por mode parámetro

Round(Decimal, Int32, MidpointRounding)

Determinado por mode parámetro

Round(Double, Int32, MidpointRounding)

Determinado por mode parámetro

Para determinar si una operación de redondeo implica un valor de punto medio, la Round método multiplica el valor original se redondea por 10n, donde n es el número deseado de dígitos fraccionarios del valor devuelto y, a continuación, determina si la parte fraccionaria restante del valor es mayor o igual a 5. Se trata de una pequeña variación en una prueba de igualdad y, como se ha descrito en la sección "Probar la igualdad" de la Double el tema de referencia, comprueba la igualdad con valores de punto flotante es problemática debido a problemas de formato de punto flotante con precisión y representación binaria. 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.

En el siguiente ejemplo se ilustra el problema. Repetidamente agrega.1 a 11.0 y redondea el resultado al entero más próximo. Independientemente de la convención de redondeo 11.5 deben redondear al 12. Sin embargo, la salida de muestra en el ejemplo, no se ejecuta. El ejemplo utiliza la "R" cadena de formato numérico estándar para mostrar de punto flotante toda la precisión del valor y muestra que el valor se redondee ha perdido la precisión durante repetidas adiciones y su valor es realmente 11.499999999999998. Como.499999999999998 es menor que 5, el valor no se redondea al entero superior siguiente. Como también se muestra en el ejemplo, este problema no surge si simplemente asignamos el valor constante 11.5 a un 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

Problemas de precisión en los valores de punto medio de redondeo están más probables que surgen en las condiciones siguientes:

En casos donde la falta de precisión en las operaciones de redondeo es problemática, puede hacer lo siguiente:

  • Si la operación de redondeo llama a una sobrecarga que redondea un Double valor, puede cambiar el Double a una Decimal valor y llamar a una sobrecarga que redondea un Decimal valor en su lugar. 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 frecuentes.

  • Definir un algoritmo personalizado de redondeo que se realiza una prueba para determinar si el valor se redondee aceptablemente está cerca de un valor de punto medio "casi igual a". En el ejemplo siguiente se define un RoundApproximate método que examina si un valor fraccionario está lo suficientemente cerca de un valor de punto medio a estar sujeto a redondeo de punto medio. Como se muestra en el resultado del ejemplo, corrige el problema de redondeo que se muestra en el ejemplo anterior.

    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
    

El Round método incluye sobrecargas que aceptan argumentos de tipo Decimal y Double. No existen métodos que redondear los valores de tipo Single. Si pasa una Single valor a una de las sobrecargas de la Round (método), se convierte (en C#) o convertir (en Visual Basic) a un Double, y la correspondiente Round sobrecarga con un Double parámetro se denomina. 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. Cuando un Single valor de 16.325 se pasa a la Round (método) y se redondea 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.

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

Este resultado inesperado es debido a la pérdida de precisión en la conversión de la Single valor a un Double. Porque resultante Double valor de 16.325000762939453 no es un valor de punto medio y es mayor que 16.325, siempre se redondea hacia arriba.

En muchos casos, como se muestra en el ejemplo, la pérdida de precisión puede minimizarse o eliminar mediante la conversión del Single valor a un Decimal. Tenga en cuenta que, puesto que se trata de una conversión de restricción, requiere mediante un operador de conversión o llamar a un método de conversión.

En el ejemplo siguiente se muestra el Round(Decimal) método. 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.

using System;

class Example
{
   static void Main()
   {
      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

En el ejemplo siguiente se muestra el redondeo al valor entero más cercano.

using System;

class Program
{
    static void Main()
    {
    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
    }
}

En el ejemplo siguiente se redondea los valores decimales con dos dígitos fraccionarios en valores que tienen un único dígito fraccionario.

using System;

public class Sample {
   static void Main() {
      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

En el ejemplo siguiente se redondea los valores double con dos dígitos fraccionarios en dobles que tienen un único dígito fraccionario.

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

El ejemplo siguiente muestra los valores devueltos por la Round(Decimal) (método), el Round(Decimal, MidpointRounding) método con un mode argumento de ToEven, y el Round(Decimal, MidpointRounding) método con un mode argumento de AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      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

El ejemplo siguiente muestra los valores devueltos por la Round(Double) (método), el Round(Double, MidpointRounding) método con un mode argumento de ToEven, y el Round(Double, MidpointRounding) método con un mode argumento de 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

En el ejemplo siguiente se muestra cómo utilizar el Round método con la MidpointRounding (enumeración).

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using System;

class Sample 
{
    public static void Main() 
    {
    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)

*/

En el ejemplo siguiente se muestra cómo utilizar el Round(Double, Int32, MidpointRounding) método con la MidpointRounding (enumeración).

using System;

class Sample 
{
    public static void Main() 
    {
       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)

.NET Framework

Sobrecargas sin un MidpointRounding parámetro se admite en: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0
sobrecargas con un MidpointRounding parámetro se admite en: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Se admiten todas las sobrecargas en: 4, 3.5 SP1

Biblioteca de clases portable

Se admiten todas las sobrecargas

.NET para aplicaciones de la Tienda Windows

Se admiten todas las sobrecargas en: Windows 8

Volver al principio
Mostrar: