Como você arredondar um número para duas casas decimais em C #?

Eu quero fazer isso usando a Math.Roundfunção

Aqui estão alguns exemplos:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Você também pode consultar os arredondamentos dos banqueiros / arredondados para o mesmo com a seguinte sobrecarga:

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

Há mais informações aqui .

Tente o seguinte:

twoDec = Math.Round(val, 2)

Pessoalmente, nunca arredondo nada. Mantenha-o o mais resoluto possível, pois o arredondamento é um arenque vermelho no CS de qualquer maneira. Mas você deseja formatar dados para seus usuários e, para esse fim, acho que string.Format("{0:0.00}", number)é uma boa abordagem.

Se você gostaria de uma string

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

Ou um decimal

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

Mas lembre-se! O arredondamento não é distributivo, ou seja. round(x*y) != round(x) * round(y). Portanto, não faça nenhum arredondamento até o final de um cálculo, caso contrário você perderá a precisão.

A Wikipedia tem uma boa página sobre arredondamentos em geral.

Todos os idiomas .NET (gerenciados) podem usar qualquer um dos mecanismos de arredondamento do CLR (Common Language Run Time). Por exemplo, o método Math.Round () (como mencionado acima) permite que o desenvolvedor especifique o tipo de arredondamento (Arredondar para o par ou Afastar do zero). O método Convert.ToInt32 () e suas variações usam o arredondamento para o par . Os métodos Ceiling () e Floor () estão relacionados.

Você também pode arredondar com formatação numérica personalizada .

Observe que Decimal.Round () usa um método diferente de Math.Round ();

Aqui está uma posição útil no algoritmo de arredondamento do banqueiro. Veja um dos posts engraçados de Raymond aqui sobre arredondamentos ...

// converte até duas casas decimais

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"

também pode combinar "0" com "#".

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"

Eu sei que é uma pergunta antiga, mas observe as seguintes diferenças entre a rodada de matemática e a rodada de formato de string :

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"

Isso é para arredondar para duas casas decimais em C #:

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

No VB.NET:

 Imports System.Math
 round(label8.text,2)

Se você deseja arredondar um número, pode obter resultados diferentes dependendo de: como você usa a função Math.Round () (se for um arredondamento para cima ou para baixo), você está trabalhando com números duplos e / ou flutuantes e você aplica o arredondamento do ponto médio. Especialmente, ao usar com operações dentro dele ou a variável a arredondar vem de uma operação. Digamos que você queira multiplicar esses dois números: 0,75 * 0,95 = 0,7125 . Direita? Não em c #

Vamos ver o que acontece se você quiser arredondar para a terceira casa 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 você vê, a primeira rodada () está correta se você deseja arredondar o ponto médio. Mas a segunda rodada () está errada se você deseja arredondar.

Isso se aplica a 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

Portanto, IMHO, você deve criar sua própria função de quebra automática para Math.Round () que atenda aos seus requisitos. Eu criei uma função na qual o parâmetro 'roundUp = true' significa arredondar para o próximo número maior. Ou seja: 0,7125 arredonda para 0,713 e -0,7125 arredonda para -0,712 (porque -0,712> -0,713). Esta é a função que eu criei e funciona para qualquer número de decimais:

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);
    }
}

A variável 'corrector' é para corrigir a imprecisão de operar com números flutuantes ou duplos.

Uma coisa que você pode querer verificar é o Mecanismo de Arredondamento da Matemática.

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

Fora isso, recomendo a abordagem Math.Round (inputNumer, numberOfPlaces) sobre a * 100/100 porque é mais limpa.

Você deve poder especificar o número de dígitos que deseja arredondar usando Math.Round (YourNumber, 2)

Você pode ler mais aqui .

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

sequência a = "10.65678";

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

Teve uma situação estranha em que eu tinha uma variável decimal, ao serializar 55.50, ele sempre define o valor padrão matematicamente como 55.5. Porém, por algum motivo, nosso sistema cliente espera seriamente 55,50 e eles definitivamente esperam decimais. Foi quando eu escrevi o auxiliar abaixo, que sempre converte qualquer valor decimal preenchido em 2 dígitos com zeros em vez de enviar uma string.

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

O uso deve ser

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

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

Resultado:

2.50
2.00

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