Как закръглявате число до два знака след десетичната запетая в C#?

Ето няколко примера:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Може също да искате да разгледате закръгляването на банкерите / от кръг до дори със следното претоварване:

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

Има повече информация за него тук.

Опитайте тази:

twoDec = Math.Round(val, 2)

Ако искаш низ

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

Или десетична запетая

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

Но помнете! Закръгляването не е разпределително, т.е. round(x*y) != round(x) * round(y). Така че не правете никакви закръгляния до самия край на изчислението, в противен случай ще загубите точност.

Лично аз никога не закръглявам нищо. Дръжте го възможно най-решително, тъй като закръгляването така или иначе е малко проблем в CS. Но вие искате да форматирате данни за вашите потребители и за тази цел намирам, че string.Format("{0:0.00}", number) е добър подход.

// конвертиране до два знака след десетичната запетая

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"

може също да комбинира "0" с "#".

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"

Уикипедия има хубава страница за закръгляването като цяло.

Всички .NET (управлявани) езици могат да използват всеки от механизмите за закръгляване на времето за изпълнение на общия език (CLR). Например Math.Round() ( както е споменато по-горе) методът позволява на разработчика да посочи типа на закръгляване (закръглено до четно или далеч от нула). Методът Convert.ToInt32() и неговите варианти използват round-to-even. Ceiling() и Floor() методите са свързани.

Можете да закръглите и с персонализирано числово форматиране.

Имайте предвид, че Decimal.Round() използва метод, различен от Math.Round();

Ето една полезна позицияза банкера алгоритъм за закръгляване. Вижте една от хумористичните публикации на Реймънд тук относно закръгляването. .

Това е за закръгляване до 2 знака след десетичната запетая в C#:

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

Във VB.NET:

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

Ако искате да закръглите число, можете да получите различни резултати в зависимост от: как използвате функцията Math.Round() (ако е за закръгляване нагоре или надолу), работите с двойни и/или плаващи числа и прилагате закръгляването на средната точка. Особено, когато се използва с операции вътре в него или променливата за закръгляване идва от операция. Да приемем, че искате да умножите тези две числа: 0,75 * 0,95 = 0,7125. нали Не в C#

Нека да видим какво се случва, ако искате да закръглите до 3-тия знак след десетичната запетая:

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

Както виждате, първият Round() е правилен, ако искате да закръглите надолу средната точка. Но вторият Round() е грешен, ако искате да закръглите.

Това се отнася за отрицателни числа:

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

Така че, IMHO, трябва да създадете своя собствена функция за обвиване за Math.Round(), която отговаря на вашите изисквания. Създадох функция, в която параметърът 'roundUp=true' означава закръгляване до следващото по-голямо число. Тоест: 0,7125 закръгля до 0,713 и -0,7125 закръгля до -0,712 (защото -0,712 > -0,713). Това е функцията, която създадох и работи за произволен брой десетични знаци:

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

Променливата 'corrector' е за коригиране на неточността при работа с плаващи или двойни числа.

Знам, че въпросът е стар, но моля, имайте предвид следните разлики между математически кръг и кръг във формат на низ:

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"

Едно нещо, което може да искате да проверите, е механизмът за закръгляване на Math.Round:

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

Освен това препоръчвам подхода Math.Round(inputNumer, numberOfPlaces) вместо този *100/100, защото е по-чист.

Трябва да можете да посочите броя на цифрите, до които искате да закръглите, като използвате Math.Round(YourNumber, 2)

Можете да прочетете повече тук.

Имах странна ситуация, в която имах десетична променлива, когато сериализирам 55.50, тя винаги задава стойност по подразбиране математически като 55.5. Но като има предвид, че нашата клиентска система сериозно очаква 55,50 по някаква причина и те определено очакваха десетична. Тогава трябваше да напиша помощника по-долу, който винаги преобразува всяка десетична стойност, подплатена до 2 цифри с нули, вместо да изпраща низ.

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

Употребата трябва да бъде

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

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

Изход:

2.50
2.00

Math.Floor(123456,646 * 100) / 100 Ще върне 123456,64

низ a = "10.65678";

десетичен d = Math.Round(Convert.ToDouble(a.ToString()),2)