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

Quiero hacer esto usando la Math.Roundfunción

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í .

Prueba esto:

twoDec = Math.Round(val, 2)

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.

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.

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

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

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"

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)

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.

Una cosa que es posible que desee verificar es el Mecanismo de redondeo de las matemáticas.

http://msdn.microsoft.com/en-us/library/system.midpointrounding.aspx

Aparte de eso, recomiendo el enfoque Math.Round (inputNumer, numberOfPlaces) sobre el * 100/100 porque es más limpio.

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

Puedes leer más aquí .

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

cadena a = "10.65678";

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

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

  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }