Как вы можете округлить число до двух знаков после запятой в С#?

Я хочу сделать это с помощью функции Math.Round

+325
02 нояб. '08 в 16:07
источник поделиться
14 ответов

Вот несколько примеров:

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

Там больше информации об этом здесь.

+546
02 нояб. '08 в 16:13
источник

Связанные вопросы


Похожие вопросы

Попробуйте следующее:

twoDec = Math.Round(val, 2)
+85
02 нояб. '08 в 16:11
источник

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

+33
23 февр. '12 в 2:01
источник

Если вам нужна строка

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

Или десятичный

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

Но помни! Округление не является дистрибутивным, т.е. round(x*y) != round(x) * round(y). Поэтому не делайте округления до самого конца вычисления, иначе вы потеряете точность.

+28
27 мар. '13 в 1:02
источник

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

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"
+13
15 янв. '16 в 9:15
источник

В Википедии есть хорошая страница об округлении в целом.

Все языки .NET(управляемые) могут использовать любой алгоритм округления CLR. Например, метод Math.Round() (как упоминалось выше) позволяет разработчику указать тип округления (круглые или четные или вдали от нуля). Метод Convert.ToInt32() и его варианты используют round-to-even. Методы Ceiling() и Floor() связаны.

Вы можете объединить пользовательское числовое форматирование.

Обратите внимание, что Decimal.Round() использует другой метод, чем Math.Round();

Вот полезный параметр по алгоритму округления банкира. См. Один из Raymond юмористический сообщения здесь об округлении...

+12
02 нояб. '08 в 16:27
источник

Я знаю его старый вопрос, но обратите внимание на следующие различия между Math round и Формат строки:

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"
+6
02 нояб. '17 в 9:12
источник

Это для округления до 2 знаков после запятой в С#:

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

В VB.NET:

 Imports System.Math
 round(label8.text,2)
+5
22 февр. '12 в 21:06
источник

Одна вещь, которую вы можете проверить, - это механизм округления Math.Round:

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

Кроме этого, я рекомендую подход Math.Round(inputNumer, numberOfPlaces) по сравнению с * 100/100, потому что он чище.

+4
02 нояб. '08 в 16:15
источник

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

Вы можете прочитать здесь.

+3
02 нояб. '08 в 16:15
источник

string a = "10.65678";

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

+1
27 нояб. '15 в 6:33
источник

Если вы хотите округлить число, вы можете получить разные результаты в зависимости от: как вы используете функцию Math.Round() (если для округления вверх или вниз), вы работаете с двойными и/или плавающими числами и вы применяете округление средней точки. Особенно, когда используется с операциями внутри него или переменная для округления происходит от операции. Допустим, вы хотите умножить эти два числа: 0,75 * 0,95 = 0,7125. Правильно? Не в С#

Давайте посмотрим, что произойдет, если вы хотите округлить до 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

Как видите, первый раунд() является правильным, если вы хотите округлить среднюю точку. Но второй раунд() это неправильно, если вы хотите округлить.

Это относится к отрицательным числам:

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. 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' предназначена для исправления неточностей работы с плавающими или двойными числами.

0
09 мая '19 в 19:58
источник
  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }
0
28 июн. '17 в 8:53
источник

Math.Floor(123456.646 * 100)/100 Вернуться 123456.64

0
30 сент. '17 в 10:52
источник

Посмотрите другие вопросы по меткам или Задайте вопрос