Cómo redondeo un valor decimal a 2 lugares decimales (para la salida en una página)

Sé que esta es una vieja pregunta, pero me sorprendió ver que nadie parecía publicar una respuesta que;

1. No utilizó el redondeo de los banqueros
2. No mantuvo el valor como decimal.

Esto es lo que usaría:

decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);

Http://msdn.microsoft.com/en-us/library/9s0xa85y.aspx

decimalVar.ToString("F");

Esto hará:

• Redondear a 2 decimales por ejemplo. 23.456 => 23.46
• Asegúrese de que son siempre 2 decimales por ejemplo. 23 => 23.00, 12.5 => 12.50

Ideal para la moneda y la visualización de cantidades monetarias.

Para documentación sobre toString ("F"): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString (con agradecimiento a Jon Schneider)

Si solo necesita esto para mostrar, use string.Formato

String.Format("{0:0.00}", 123.4567m);      // "123.46"

Http://www.csharp-examples.net/string-format-double /

La "m" es un sufijo decimal. Acerca del sufijo decimal:

Http://msdn.microsoft.com/en-us/library/364x0z75.aspx

Dado decimal d=12.345; las expresiones d.ToString("C") o Cadena.Format ("{0: C}", d) yield $12.35 - tenga en cuenta que se utilizan los ajustes de moneda de la cultura actual, incluido el símbolo.

Tenga en cuenta que "C" utiliza el número de dígitos de la cultura actual. Siempre puede anular el valor predeterminado para forzar la precisión necesaria con C{Precision specifier} como String.Format("{0:C2}", 5.123d).

Si lo desea formateado con comas, así como un punto decimal (pero sin símbolo de moneda), como 3,456,789.12...

decimalVar.ToString("n2");

Ya hay dos respuestas de puntuación alta que se refieren al decimal.Ronda(... pero creo que se necesita un poco más de explicación, porque hay una propiedad importante inesperada de Decimal que no es obvia.

Un decimal 'sabe' cuántos lugares decimales tiene basado en de dónde vino.

Por ejemplo, lo siguiente puede ser inesperado:

Decimal.Parse("25").ToString()          =>   "25"
Decimal.Parse("25.").ToString()         =>   "25"
Decimal.Parse("25.0").ToString()        =>   "25.0"
Decimal.Parse("25.0000").ToString()     =>   "25.0000"

25m.ToString()                          =>   "25"
25.000m.ToString()                      =>   "25.000"

Hacer las mismas operaciones con Double no dará lugar a decimales ("25") para cada uno de los anteriores.

Cuando quieres un decimal a 2 decimales hay alrededor de un 95% de probabilidad es porque es moneda en cuyo caso esto es probablemente bien para el 95% de las veces:

Decimal.Parse("25.0").ToString("c")     =>   "$25.00"

O en XAML solo usa {Binding Price, StringFormat=c}

Un caso en el que me encontré donde necesitaba un decimal COMO decimal fue al enviar XML al servicio web de Amazon. El servicio se quejaba porque un valor decimal (originalmente de SQL Server) estaba siendo enviado como 25.1200 y rechazado, (25.12 era el formato esperado).

Todo lo que necesitaba hacer fue Decimal.Round(...) con 2 decimales para solucionar el problema.

 // This is an XML message - with generated code by XSD.exe
 StandardPrice = new OverrideCurrencyAmount()
 {
       TypedValue = Decimal.Round(product.StandardPrice, 2),
       currency = "USD"
 }

TypedValue es de tipo Decimal así que no podía simplemente hacer ToString("N2") y necesitaba redondearlo y mantenerlo como decimal.

Aquí hay un pequeño programa Linqpad para mostrar diferentes formatos:

void Main()
{
    FormatDecimal(2345.94742M);
    FormatDecimal(43M);
    FormatDecimal(0M);
    FormatDecimal(0.007M);
}

public void FormatDecimal(decimal val)
{
    Console.WriteLine("ToString: {0}", val);
    Console.WriteLine("c: {0:c}", val);
    Console.WriteLine("0.00: {0:0.00}", val);
    Console.WriteLine("0.##: {0:0.##}", val);
    Console.WriteLine("===================");
}

Aquí están los resultados:

ToString: 2345.94742
c: $2,345.95
0.00: 2345.95
0.##: 2345.95
===================
ToString: 43
c: $43.00
0.00: 43.00
0.##: 43
===================
ToString: 0
c: $0.00
0.00: 0.00
0.##: 0
===================
ToString: 0.007
c: $0.01
0.00: 0.01
0.##: 0.01
===================

Matemáticas.Método redondo (Decimal, Int32)

Ninguno de ellos hizo exactamente lo que necesitaba, para forzar 2 d. p. y redondear como 0.005 -> 0.01

Forzar 2 d. p.requiere aumentar la precisión en 2 d. p.para asegurar que tengamos al menos 2 d. p.

Luego redondeo para asegurar que no tenemos más de 2 d.p.

Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)

6.665m.ToString() -> "6.67"

6.6m.ToString() -> "6.60"

Puede usar el sistema.globalization to format a number in any required format.

Por ejemplo:

system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");

Si tiene un decimal d = 1.2300000 y necesita recortarlo a 2 decimales, entonces se puede imprimir así d.Tostring("F2",ci); donde F2 es una cadena de formato a 2 decimales y ci es la locale o cultureinfo.

Para obtener más información, consulte este enlace
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx

La respuesta mejor valorada describe un método para formatear la representación de cadena del valor decimal, y funciona.

Sin embargo, si realmente desea cambiar la precisión guardada al valor real, debe escribir algo como lo siguiente:

public static class PrecisionHelper
{
    public static decimal TwoDecimalPlaces(this decimal value)
    {
        // These first lines eliminate all digits past two places.
        var timesHundred = (int) (value * 100);
        var removeZeroes = timesHundred / 100m;

        // In this implementation, I don't want to alter the underlying
        // value.  As such, if it needs greater precision to stay unaltered,
        // I return it.
        if (removeZeroes != value)
            return value;

        // Addition and subtraction can reliably change precision.  
        // For two decimal values A and B, (A + B) will have at least as 
        // many digits past the decimal point as A or B.
        return removeZeroes + 0.01m - 0.01m;
    }
}

Un ejemplo de prueba unitaria:

[Test]
public void PrecisionExampleUnitTest()
{
    decimal a = 500m;
    decimal b = 99.99m;
    decimal c = 123.4m;
    decimal d = 10101.1000000m;
    decimal e = 908.7650m

    Assert.That(a.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("500.00"));

    Assert.That(b.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("99.99"));

    Assert.That(c.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("123.40"));

    Assert.That(d.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("10101.10"));

    // In this particular implementation, values that can't be expressed in
    // two decimal places are unaltered, so this remains as-is.
    Assert.That(e.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("908.7650"));
}

Muy raramente querrías una cadena vacía si el valor es 0.

decimal test = 5.00;
test.ToString("0.00");  //"5.00"
decimal? test2 = 5.05;
test2.ToString("0.00");  //"5.05"
decimal? test3 = 0;
test3.ToString("0.00");  //"0.00"

La respuesta mejor valorada es incorrecta y ha perdido 10 minutos de (la mayoría) el tiempo de las personas.

Https://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx

Este enlace explica en detalle cómo puede manejar su problema y qué puede hacer si desea obtener más información. Por razones de simplicidad, lo que desea hacer es

double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");

Si desea esto para una moneda, puede hacerlo más fácil escribiendo "C2" en lugar de "F2"

La respuesta de Mike M. fue perfecta para mí en.NET, pero. NET Core no tiene un método decimal.Round en el momento de escribir.

En. NET Core, tuve que usar:

decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);

Un método hacky, incluyendo la conversión a cadena, es:

public string FormatTo2Dp(decimal myNumber)
{
    // Use schoolboy rounding, not bankers.
    myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero);

    return string.Format("{0:0.00}", myNumber);
}