¿Cómo redondeas un número a dos decimales en C #?

Respuestas:

629

Aquí hay algunos ejemplos:

decimal a = 1.994444M;

Math.Round(a, 2); //returns 1.99

decimal b = 1.995555M;

Math.Round(b, 2); //returns 2.00

También es posible que desee mirar a los banqueros redondeando / redondeando a pares con la siguiente sobrecarga:

Math.Round(a, 2, MidpointRounding.ToEven);

Hay más información al respecto aquí .

Eoin Campbell
fuente
51
Debe aclarar que MidPointRounding.ToEven ES el valor predeterminado. Si quisieras AwayFromZero tendrías que usar la sobrecarga
Brian Vander Plaats
55
Si desea redondear hasta 2 decimales, agregue 0.005el número antes de redondear. Del mismo modo para redondear hacia abajo , restar 0.005antes de pasar a la Math.Roundfunción.
2015
44
La razón por la que .NET se predetermina MidPointRounding.ToEven(también conocido como "Redondeo de banqueros") es porque todos aprendimos a redondear en la escuela donde .5 redondea causa demasiado redondeo. Este es un problema cuando se trata de dinero, cálculos de impuestos, etc.
según el
97

Prueba esto:

twoDec = Math.Round(val, 2)
John Boker
fuente
33

Personalmente nunca redondeo nada. Manténgalo lo más resuelto posible, ya que el redondeo es un arenque rojo en CS de todos modos. Pero sí desea formatear los datos para sus usuarios, y para ese fin, creo que string.Format("{0:0.00}", number)es un buen enfoque.

Gleno
fuente
Esto funciona mejor para fines de visualización, especialmente por dinero, ya que £ 5.4 (con Math.round) no se ve tan bien como £ 5.40 (de esta manera).
Peter Gordon
He intentado antes string.Format ("0: 0.00", número), pero no funcionó. Esos corchetes son muy importantes, entonces: string.Format ("{0: 0.00}", número) funciona.
FrenkyB
8
@FrenkyB Cuando dices "corchetes", espero que te refieras a llaves.
Mathemats
Esto también redondea. 1.009 => 1.01
Donny V.
30

Si quieres una cuerda

> (1.7289).ToString("#.##")
"1.73"

O un decimal

> Math.Round((Decimal)x, 2)
1.73m

¡Pero recuerda! El redondeo no es distributivo, es decir. round(x*y) != round(x) * round(y). Por lo tanto, no redondee hasta el final de un cálculo, de lo contrario perderá precisión.

Coronel Panic
fuente
14

Wikipedia tiene una buena página sobre redondeo en general.

Todos los lenguajes .NET (administrados) pueden usar cualquiera de los mecanismos de redondeo del tiempo de ejecución de lenguaje común (CLR). Por ejemplo, el método Math.Round () (como se mencionó anteriormente) permite al desarrollador especificar el tipo de redondeo (Round-to-even o Away-from-zero). El método Convert.ToInt32 () y sus variaciones usan redondeo a par . Los métodos Ceiling () y Floor () están relacionados.

También puede redondear con formato numérico personalizado .

Tenga en cuenta que Decimal.Round () usa un método diferente que Math.Round ();

Aquí hay una posición útil sobre el algoritmo de redondeo del banco. Vea una de las publicaciones humorísticas de Raymond aquí sobre redondeo ...

Foredecker
fuente
13

// convierte hasta dos decimales

String.Format("{0:0.00}", 140.6767554);        // "140.67"
String.Format("{0:0.00}", 140.1);             // "140.10"
String.Format("{0:0.00}", 140);              // "140.00"

Double d = 140.6767554;
Double dc = Math.Round((Double)d, 2);       //  140.67

decimal d = 140.6767554M;
decimal dc = Math.Round(d, 2);             //  140.67

=========

// just two decimal places
String.Format("{0:0.##}", 123.4567);      // "123.46"
String.Format("{0:0.##}", 123.4);         // "123.4"
String.Format("{0:0.##}", 123.0);         // "123"

También puede combinar "0" con "#".

String.Format("{0:0.0#}", 123.4567)       // "123.46"
String.Format("{0:0.0#}", 123.4)          // "123.4"
String.Format("{0:0.0#}", 123.0)          // "123.0"
Rae Lee
fuente
1
String.Format ("{0: 0.00}", 140.6767554); ! = "140.67" En realidad se presenta como "140.68" - redondeando
AndyT
7

Sé que es una pregunta antigua, pero tenga en cuenta las siguientes diferencias entre la ronda matemática y la ronda de formato de cadena :

decimal d1 = (decimal)1.125;
Math.Round(d1, 2).Dump();   // returns 1.12
d1.ToString("#.##").Dump(); // returns "1.13"

decimal d2 = (decimal)1.1251;
Math.Round(d2, 2).Dump();   // returns 1.13
d2.ToString("#.##").Dump(); // returns "1.13"
Guy P
fuente
6

Esto es para redondear a 2 decimales en C #:

label8.Text = valor_cuota .ToString("N2") ;

En VB.NET:

 Imports System.Math
 round(label8.text,2)
sadim
fuente
5

Si desea redondear un número, puede obtener diferentes resultados dependiendo de: cómo use la función Math.Round () (si es un redondeo hacia arriba o hacia abajo), está trabajando con números de dobles y / o flotantes , y aplica el redondeo del punto medio. Especialmente, cuando se usa con operaciones dentro de él o la variable a redondear proviene de una operación. Digamos que desea multiplicar estos dos números: 0.75 * 0.95 = 0.7125 . ¿Derecha? No en C #

Veamos qué sucede si quieres redondear al tercer decimal:

double result = 0.75d * 0.95d; // result = 0.71249999999999991
double result = 0.75f * 0.95f; // result = 0.71249997615814209

result = Math.Round(result, 3, MidpointRounding.ToEven); // result = 0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = 0.712. Should be 0.713

Como puede ver, la primera ronda () es correcta si desea redondear hacia abajo el punto medio. Pero la segunda ronda () está mal si quieres redondear.

Esto se aplica a los números negativos:

double result = -0.75 * 0.95;  //result = -0.71249999999999991
result = Math.Round(result, 3, MidpointRounding.ToEven); // result = -0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = -0.712. Should be -0.713

Entonces, en mi humilde opinión, debe crear su propia función de ajuste para Math.Round () que se ajuste a sus requisitos. Creé una función en la cual, el parámetro 'roundUp = true' significa redondear al siguiente número mayor. Es decir: 0.7125 se redondea a 0.713 y -0.7125 se redondea a -0.712 (porque -0.712> -0.713). Esta es la función que creé y funciona para cualquier número de decimales:

double Redondea(double value, int precision, bool roundUp = true)
{
    if ((decimal)value == 0.0m)
        return 0.0;

    double corrector = 1 / Math.Pow(10, precision + 2);

    if ((decimal)value < 0.0m)
    {
        if (roundUp)
            return Math.Round(value, precision, MidpointRounding.ToEven);
        else
            return Math.Round(value - corrector, precision, MidpointRounding.AwayFromZero);
    }
    else
    {
        if (roundUp)
            return Math.Round(value + corrector, precision, MidpointRounding.AwayFromZero);
        else
            return Math.Round(value, precision, MidpointRounding.ToEven);
    }
}

La variable 'corrector' es para corregir la inexactitud de operar con números flotantes o dobles.

fedesanp
fuente
3

Debería poder especificar el número de dígitos que desea redondear usando Math.Round (YourNumber, 2)

Puedes leer más aquí .

Kevin W Lee
fuente
2

Math.Floor (123456.646 * 100) / 100 Devuelve 123456.64

usuario3405179
fuente
1

cadena a = "10.65678";

decimal d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

Abhishek Jaiswal
fuente
1

Tuve una situación extraña en la que tenía una variable decimal, al serializar 55.50 siempre establece el valor predeterminado matemáticamente como 55.5. Pero mientras, nuestro sistema de cliente espera seriamente 55.50 por alguna razón y definitivamente esperaban decimal. Eso fue cuando escribí el siguiente ayudante, que siempre convierte cualquier valor decimal rellenado a 2 dígitos con ceros en lugar de enviar una cadena.

public static class DecimalExtensions
{
    public static decimal WithTwoDecimalPoints(this decimal val)
    {
        return decimal.Parse(val.ToString("0.00"));
    }
}

El uso debe ser

var sampleDecimalValueV1 = 2.5m;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

decimal sampleDecimalValueV1 = 2;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

Salida:

2.50
2.00
Riyaz Hameed
fuente
0
  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }
Ruan
fuente