Як округлити число до двох знаків після коми у C #?

Я хочу це зробити за допомогою Math.Roundфункції

Ось кілька прикладів:

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)

Особисто я ніколи нічого не округляю. Тримайте це якомога рішучіше, оскільки округлення так чи інакше є червоною оселедцем у CS. Але ви хочете форматувати дані для своїх користувачів, і для цього я вважаю, що string.Format("{0:0.00}", number)це хороший підхід.

Якщо ви хочете рядок

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

Або десятковий

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

Але пам’ятайте! Округлення не є розподільним, тобто. round(x*y) != round(x) * round(y). Тому не робіть жодного округлення до самого кінця розрахунку, інакше ви втратите точність.

У Вікіпедії є приємна сторінка щодо округлення взагалі.

Усі .NET (керовані) мови можуть використовувати будь-які механізми округлення загальної мови (CLR). Наприклад, метод Math.Round () (як згадувалося вище) дозволяє розробнику вказувати тип округлення (Раунд-рівний або Вдалиний-від нуля). Метод Convert.ToInt32 () та його варіації використовують кругле до рівного . Методи Ceiling () та Floor () пов'язані між собою.

Ви також можете закріпити за допомогою спеціального цифрового форматування .

Зауважте, що Decimal.Round () використовує інший метод, ніж Math.Round ();

Ось корисна позиція щодо алгоритму округлення банкіра. Дивіться одну з жартівливих публікацій Реймонда тут про округлення ...

// конвертувати до двох знаків після коми

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"

Я знаю, що це давнє запитання, але, будь ласка, зверніть увагу на такі відмінності між Math Round і 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"

Це для округлення до двох знаків після коми у 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 #

Давайте подивимося, що станеться, якщо ви хочете округлити до третьої десяткової:

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

Як бачите, перший раунд () є правильним, якщо ви хочете округлити середину. Але другий тур () неправильний, якщо ви хочете округлити його.

Це стосується негативних чисел:

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

Змінна 'коректор' призначена для виправлення неточності роботи з плаваючими чи подвійними числами.

Одне, що ви можете перевірити - це Механізм округлення Math.Round:

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

Крім цього, я рекомендую підхід Math.Round (inputNumer, numberOfPlaces) над * 100/100, оскільки він чистіший.

Ви повинні мати можливість вказати кількість цифр, які ви хочете округлити, використовуючи Math.Round (YourNumber, 2)

Більше ви можете прочитати тут .

Math.Floor (123456.646 * 100) / 100 Повернеться 123456.64

рядок a = "10,65678";

десяткова d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

Якщо у нас була дивна ситуація, коли у мене була десяткова змінна, при серіалізації 55,50 вона завжди встановлює значення за замовчуванням математично як 55,5. Але тоді як наша клієнтська система чомусь серйозно очікує 55,50, і вони, безумовно, очікують десяткової. Ось тоді я писав помічник нижче, який завжди перетворює будь-яке десяткове значення, додане до двох цифр з нулями, а не надсилає рядок.

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

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