Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Math.Round (Método)

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

Este miembro está sobrecargado. Para obtener información completa sobre este miembro, incluida la sintaxis, el uso y algunos ejemplos, haga clic en un nombre de la lista de sobrecarga.

  Nombre Descripción
Método público Miembro estático Round(Decimal) Redondea un valor decimal al valor integral más próximo.
Método público Miembro estático Round(Double) Redondea un valor de punto flotante de precisión doble al valor integral más cercano.
Método público Miembro estático Round(Decimal, Int32) Redondea un valor decimal al número especificado de dígitos fraccionarios.
Método público Miembro estático Round(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.
Método público Miembro estático Round(Double, Int32) Redondea un valor de punto flotante de precisión doble al número especificado de dígitos fraccionarios.
Método público Miembro estático Round(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.
Método público Miembro estático Round(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.
Método público Miembro estático Round(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.
Arriba

En esta sección:

Sintaxis sobrecargada del método
Parámetros
Valor devuelto
Excepciones
¿Qué método denomino?
Valores de punto medio y convenciones redondeo
Redondeo y precisión
Valores de punto flotante redondeo y de precisión sencilla
Ejemplos:
       Math.Round (Decimal)
       Math.Round (doble)
       Math.Round (Decimal, Int32)
       Math.Round (Decimal, MidpointRounding)
       Math.Round (double, Int32)
       Math.Round (double, MidpointRounding)
       Math.Round (Decimal, Int32, MidpointRounding)
       Math.Round (double, Int32, MidpointRounding)
Información de versión

Sintaxis sobrecargada del método

Para obtener orientación adicional sobre cómo elegir una sobrecarga, vea ¿Qué método denomino?

Decimal Math.Round(Decimal d )

Redondea un valor decimal al entero más próximo, y redondea valores de punto medio el número par más próximo (ejemplo).

Double Math.Round(Double a )

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

Decimal Math.Round(Decimal d , Int32 decimals )

Redondea un valor decimal en un número especificado de dígitos fraccionarios, y redondea valores de punto medio el número par más próximo (ejemplo).

Double Math.Round(Double value , Int32 digits )

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios, y redondea valores de punto medio el número par más próximo (ejemplo).

Decimal Math.Round(Decimal d , MidpointRounding mode )

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

Double Math.Round(Double value , MidpointRounding mode )

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

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

Redondea un valor decimal en un número especificado de dígitos fraccionarios, y usan la convención de redondeo especificada por valores de punto medio (ejemplo).

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

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios, y usan la convención de redondeo especificada por valores de punto medio (ejemplo).

Parámetros

Ésta es una lista completa de parámetros para el método de Round . Para los parámetros utilizados por cada sobrecarga, vea la sintaxis de sobrecarga anteriormente.

Parámetro

Tipo

Descripción

d

Decimal

Un número que se 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 los valores de Decimal , puede variar del 0 al 28. Para los valores de Double , puede variar del 0 al 15. Observe que 15 es el número máximo de dígitos enteros y fraccionarios admitidos por el tipo de Double .

Valor predeterminado: 0, que redondea a un entero

mode

MidpointRounding

Una marca que especifica la convención para utilizar para que los valores de punto medio. Vea Valores de punto medio y convenciones redondeo.

Valor predeterminado: MidpointRounding.ToEven

Valor devuelto

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

Nota de precaución Precaución

Al que los valores de punto medio, el algoritmo de redondeo realiza una comprobación de igualdad. Debido a problemas de representación binaria y de precisión en formato flotante, el valor devuelto por el método puede ser inesperado. Para obtener más información, vea Redondeo y precisión.

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

Excepciones

¿Qué método denomino?

Para

Call

Alrededor de un número en un entero utilizando el redondeo la convención más próxima.

Round(Decimal)

O bien

Round(Double)

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

Round(Decimal, MidpointRounding)

O bien

Round(Double, MidpointRounding)

Alrededor de un número a un número especificado de dígitos fraccionarios mediante redondeo la convención más próxima.

Round(Decimal, Int32)

O bien

Round(Double, Int32)

Alrededor de un número a un número especificado de dígitos fraccionarios utilizando la convención de redondeo especificada.

Round(Decimal, Int32, MidpointRounding)

O bien

Round(Double, Int32, MidpointRounding)

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

Convierte Single a Decimal y llame a Round(Decimal, Int32, MidpointRounding).

Alrededor de un número a un número especificado de dígitos fraccionarios mientras minimiza problemas de precisión en que los valores de punto medio.

Llame a un método de redondeo que implementa un “mayor o aproximadamente igual a” comparación. Vea Redondeo y precisión.

Alrededor de un valor fraccionario en un entero que es mayor que el valor fraccionario. Por ejemplo, alrededor de 3,1 a 4.

Ceiling

Alrededor de un valor fraccionario en un entero que es menor que el valor fraccionario. Por ejemplo, alrededor de 3,9 a 3.

Floor

Valores de punto medio y convenciones redondeo

Redondeo implica convertir un valor numérico con una precisión especificada al valor más próximo con menos precisión. Por ejemplo, puede utilizar el método de Round(Double) para redondear un valor de 3,4 a 3,0, y el método de Round(Double, Int32) para redondear un valor de 3,579 a 3,58.

En un valor de punto medio, el valor después de menos dígito significativo del resultado es precisamente medio camino entre dos números. Por ejemplo, 3,47500 es un valor de punto medio si se van a redondeadas dos posiciones decimales, y 7,500 es un valor de punto medio si se van a redondeado a un entero. En estos casos, el valor más cercano no se puede identificar sin una convención de redondeo.

El método de Round admite a dos convenciones que redondean para administrar la configuración de punto medio:

Redondeo lejos de cero

Los valores de punto medio se redondean el número siguiente lejos de cero. Por ejemplo, 3,75 rondas a 3,8, 3,85 rondas a 3,9, -3,75 rondas a -3,8, y -3,85 rondas a -3,9. Este formulario de redondeo representa el miembro de enumeración de MidpointRounding.AwayFromZero .

Redondeo lejos de cero es el formulario más ampliamente posible conocido de redondeo.

Redondeo a más cercana, o el redondeo del banquero

Los valores de punto medio se redondean al número par más próximo. Por ejemplo, 3,75 y 3,85 redondos en 3,8, y -3,75 y -3,85 redondos en -3,8. Este formulario de redondeo representa el miembro de enumeración de MidpointRounding.ToEven .

Redondeo más cercana es el formulario estándar de redondeo utilizado en operaciones financieras y estadísticas. Se ajusta a IEEE el estándar 754, sección 4. Cuando se usa en el múltiplo de redondeo operaciones, reduce el error de redondeo que se derivan de redondeo valores de punto medio en una sola dirección. En algunos casos, este error de redondeo puede ser considerable.

El ejemplo siguiente se muestra el tendencia que puede producirse coherente de que los valores de punto medio en una sola dirección. El ejemplo calcula el medio real de una matriz de valores de Decimal , y después calcula el medio cuando los valores de la matriz se redondean con dos convenciones. En este ejemplo, el medio auténtico y medio que los resultados al redondeo más cercana son iguales. Sin embargo, el medio que resultados cuando el redondeo lejos de cero diferencia por .05 (o en 3,6%) medio verdadero.


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, el método de Round utiliza el redondeo la convención más próxima. La tabla siguiente se muestran las sobrecargas del método de Round y la convención de redondeo que cada utiliza.

Sobrecarga

Redondear la convención

Round(Decimal)

ToEven

Round(Double)

ToEven

Round(Decimal, Int32)

ToEven

Round(Double, Int32)

ToEven

Round(Decimal, MidpointRounding)

Determinado por el parámetro de mode .

Round(Double, MidpointRounding)

Determinado por el parámetro de mode

Round(Decimal, Int32, MidpointRounding)

Determinado por el parámetro de mode

Round(Double, Int32, MidpointRounding)

Determinado por el parámetro de mode

Redondeo y precisión

Para determinar si una operación de redondeo implica un valor de punto medio, el método de Round multiplica el valor original se redondee por 10n, donde es el número n deseado de dígitos fraccionarios en el valor devuelto y, a continuación determina si la fracción restante del valor es mayor o igual que .5. Esto es una ligera variación en una prueba de igualdad, como se describe en la sección “probar para la sección de Equality” del tema de referencia de Double , las pruebas de igualdad con valores de punto flotante es problemático debido a problemas de formato flotante con la representación binaria y precisión. Esto significa que no redondearán a cualquier fracción de un número algo menos de .5 (debido a una pérdida de precisión) hacia arriba.

En el siguiente ejemplo se ilustra el problema. Agrega repetidamente .1 a 11,0 y redondea el resultado al entero más próximo. Independientemente de la convención de redondeo, 11,5 si redondo a 12. Sin embargo, como el resultado del ejemplo, no. El ejemplo utiliza la “r” cadena de formato numérico estándar para mostrar la precisión completa de valores de punto flotante, y muestra que el valor se redondee ha perdido la precisión durante adiciones repetidas, y su valor es realmente 11,499999999999998. Porque .499999999999998 es menor que .5, no se redondea al entero más alto siguiente. Mientras el ejemplo también muestra, este problema no se produce si asignar simplemente el valor constante 11,5 a una variable de Double .


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 que los valores de punto medio son más probable de surgir en las condiciones siguientes:

En caso de que la falta de precisión en el redondeo operaciones es problemática, puede hacer lo siguiente:

  • Si la operación de redondeo llamar a una sobrecarga que redondee un valor de Double , puede cambiar Double a un valor de Decimal y llamar a una sobrecarga que redondee un valor de Decimal en su lugar. Aunque el tipo de datos de Decimal tenga problemas de representación y pérdida de precisión, estos problemas se mucho menos comunes.

  • Defina un algoritmo de redondeo personalizado que realiza una prueba “casi” para determinar si el valor se redondeadas es aceptable cerca de un valor de punto medio. El ejemplo siguiente se define un método de RoundApproximate que examine si un valor fraccionario se suficientemente por un valor de punto medio a estar bajo redondear el punto intermedio. Como muestra el resultado del ejemplo, corrija el problema de redondeo mostrada 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
    
    
    

Valores de punto flotante redondeo y de precisión sencilla

El método de Round incluye sobrecargas que aceptan argumentos de Decimal escrito y de Double. No hay métodos esos valores redondos de Singleescrito. Si se pasa un valor de Single a una de las sobrecargas del método de Round , se convierte (en C#) o se convierte (en Visual Basic) a Double, y la sobrecarga correspondiente de Round con un parámetro de Double se denomina. Aunque esto es una conversión de ampliación, a menudo implica una pérdida de precisión, como muestra el ejemplo siguiente. Cuando un valor de Single de 16,325 se pasa al método de Round y se redondean a dos posiciones decimales mediante redondeo la convención más cercana, el resultado es 16,33 y no el resultado 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 una pérdida de precisión en la conversión del valor de Single a Double. Dado que el valor resultante de Double de 16,325000762939453 no es un valor de punto medio y es mayor que 16,325, se redondea siempre hacia arriba.

En muchos casos, como muestra el ejemplo, la pérdida de precisión puede minimizar o eliminar convertir o convertir el valor de Single a Decimal. Observe que, porque es una conversión de restricción, requiere mediante para convertir el operador o llamar a un método de conversión.

Ejemplo de Math.Round (Decimal)

En el siguiente ejemplo se muestra el método Round(Decimal). Observe que el valor de Decimal de 4,5 rondas a 4 en lugar de 5, porque esta sobrecarga utiliza la convención predeterminada de ToEven .


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


Ejemplo (doble) de Math.Round

El ejemplo siguiente 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
    }
}


Ejemplo de Math.Round (Decimal, Int32)

El ejemplo siguiente redondea los valores decimales con dos dígitos fraccionarios a los valores con un solo 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


Ejemplo de Math.Round (double, Int32)

El ejemplo siguiente redondea valores double con dos dígitos fraccionarios a doubles 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


Ejemplo de Math.Round (Decimal, MidpointRounding)

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


Ejemplo de Math.Round (double, MidpointRounding)

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


Ejemplo de Math.Round (Decimal, Int32, MidpointRounding)

El ejemplo siguiente muestra cómo utilizar el método de Round con la enumeración de MidpointRounding .


// 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)

*/


Ejemplo de Math.Round (double, Int32, MidpointRounding)

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


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)


Información de versión

.NET Framework

Las sobrecargas sin un parámetro de MidpointRounding se admiten en: 4,5, 4, 3,5, 3,0, 2,0, 1,1, 1,0
Las sobrecargas con un parámetro de MidpointRounding se admiten en: 4,5, 4, 3,5, 3,0, 2,0

.NET Framework Client Profile

Todas las sobrecargas se admiten en: 4, 3,5 SP1

Biblioteca de clases portable

Se admiten todas las sobrecargas

.NET para aplicaciones de la Tienda Windows

Todas las sobrecargas se admiten en: Windows 8

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft