Как округлить число до двух десятичных знаков в C#?

Question

Как округлить число до двух десятичных знаков в C#?

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

495

c# decimal rounding bankers-rounding

Источник

02 ноя '08 в 16:07

16 ответов

Другие вопросы по тегам c# decimal rounding bankers-rounding

user30155 02 ноя '08 в 16:13 2008-11-02 16:13 · Answer 1 · 2008-11-02 16:13

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

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

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

813

Источник

user30155 02 ноя '08 в 16:13

user2847 02 ноя '08 в 16:11 2008-11-02 16:11 · Answer 2 · 2008-11-02 16:11

Попробуй это:

twoDec = Math.Round(val, 2)

125

Источник

user2847 02 ноя '08 в 16:11

user284795 27 мар '13 в 01:02 2013-03-27 01:02 · Answer 3 · 2013-03-27 01:02

Если вы хотите строку

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

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

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

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

48

Источник

user284795 27 мар '13 в 01:02

user427673 23 фев '12 в 02:01 2012-02-23 02:01 · Answer 4 · 2012-02-23 02:01

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

user5113582 15 янв '16 в 09:15 2016-01-15 09:15 · Answer 5 · 2016-01-15 09:15

// конвертируем до двух десятичных знаков

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"

user18256 02 ноя '08 в 16:27 2008-11-02 16:27 · Answer 6 · 2008-11-02 16:27

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

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

Вы можете округлить с пользовательским числовым форматированием, а также.

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

Вот полезная позиция по алгоритму округления банкира. Смотрите один из юмористических постов Рэймонда здесь о округлении...

user2690533 09 май '19 в 22:58 2019-05-09 22:58 · Answer 7 · 2019-05-09 22:58

Если вы хотите округлить число, вы можете получить разные результаты в зависимости от: того, как вы используете функцию Math.Round() (если для округления вверх или вниз), вы работаете с числами типа double и / или float., и вы примените округление средней точки. Особенно, когда используется с операциями внутри него или переменная для округления происходит от операции. Допустим, вы хотите умножить эти два числа: 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

Как видите, первый 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);
    }
}

Переменная "корректор" предназначена для исправления неточности работы с плавающими или двойными числами.

user1226874 22 фев '12 в 21:06 2012-02-22 21:06 · Answer 8 · 2012-02-22 21:06

Это для округления до 2 десятичных знаков в C#:

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

В VB.NET:

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

9

Источник

user1226874 22 фев '12 в 21:06

user1570636 11 сен '19 в 16:09 2019-09-11 16:09 · Answer 9 · 2019-09-11 16:09

Была странная ситуация, когда у меня была десятичная переменная, при сериализации 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

user1252723 02 ноя '17 в 09:12 2017-11-02 09:12 · Answer 10 · 2017-11-02 09:12

Я знаю, что это старый вопрос, но, пожалуйста, обратите внимание на следующие различия между раундом Math и 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"

7

Источник

user1252723 02 ноя '17 в 09:12

user91 02 ноя '08 в 16:15 2008-11-02 16:15 · Answer 11 · 2008-11-02 16:15

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

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

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

4

Источник

user91 02 ноя '08 в 16:15

user26474 02 ноя '08 в 16:15 2008-11-02 16:15 · Answer 12 · 2008-11-02 16:15

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

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

3

Источник

user26474 02 ноя '08 в 16:15

user3247491 29 июл '23 в 12:21 2023-07-29 12:21 · Answer 13 · 2023-07-29 12:21

Просто решает эту проблему и соответствует ситуации, передавprecisionпараметр и параметр метода.

По умолчаниюMath.RoundиспользуетMidpointRounding.ToEvenчто на самом делеbankers roundingэто означает, что средние числа округляются до ближайшего четного числа:

      1.5 => 2
2.5 => 2
3.5 => 4
4.5 => 4

Позвольте мне внести ясность. На самом деле существует 5 стратегийMidpointRoundingты можешь взять, чтобы получить то, от чего ожидаешьMath.Round():

ToEven (по умолчанию) Если число находится посередине между двумя другими, оно округляется в сторону ближайшего четного числа.
AwayFromZero (математическое округление). Если число находится посередине между двумя другими, оно округляется в сторону ближайшего числа от нуля. (Ака, округлить вверх)
ToZero округляет число в меньшую сторону с заданной точностью.
ToNegativeInfinity (минимум) округляет число в меньшую сторону с заданной точностью.
ToPositiveInfinity (потолок) округляет число в большую сторону в зависимости от заданной точности.

Вот код, чтобы увидеть, как именно они работают:

      var num1 = 1.5;
var num2 = 2.5;
var num3 = 3.5;
var num4 = 2.51;
var num5 = 2.48;

Console.WriteLine("----------------Round with MidpointRounding.ToEven (default) ---------------------");
Console.WriteLine($"{num1} => {Math.Round(num1, MidpointRounding.ToEven)}");
Console.WriteLine($"{num2} => {Math.Round(num2, MidpointRounding.ToEven)}");
Console.WriteLine($"{num3} => {Math.Round(num3, MidpointRounding.ToEven)}");
Console.WriteLine($"{num4} => {Math.Round(num4, MidpointRounding.ToEven)}");
Console.WriteLine($"{num5} => {Math.Round(num5, MidpointRounding.ToEven)}");

Console.WriteLine("----------------Round with MidpointRounding.AwayFromZero (mathematical rounding) ---------------------");
Console.WriteLine($"{num1} => {Math.Round(num1, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"{num2} => {Math.Round(num2, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"{num3} => {Math.Round(num3, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"{num4} => {Math.Round(num4, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"{num5} => {Math.Round(num5, MidpointRounding.AwayFromZero)}");

Console.WriteLine("----------------Round with MidpointRounding.ToZero ---------------------");
Console.WriteLine($"{num1} => {Math.Round(num1, MidpointRounding.ToZero)}");
Console.WriteLine($"{num2} => {Math.Round(num2, MidpointRounding.ToZero)}");
Console.WriteLine($"{num3} => {Math.Round(num3, MidpointRounding.ToZero)}");
Console.WriteLine($"{num4} => {Math.Round(num4, MidpointRounding.ToZero)}");
Console.WriteLine($"{num5} => {Math.Round(num5, MidpointRounding.ToZero)}");

Console.WriteLine("----------------Round with MidpointRounding.ToNegativeInfinity (floor) ---------------------");
Console.WriteLine($"{num1} => {Math.Round(num1, MidpointRounding.ToNegativeInfinity)}");
Console.WriteLine($"{num2} => {Math.Round(num2, MidpointRounding.ToNegativeInfinity)}");
Console.WriteLine($"{num3} => {Math.Round(num3, MidpointRounding.ToNegativeInfinity)}");
Console.WriteLine($"{num4} => {Math.Round(num4, MidpointRounding.ToNegativeInfinity)}");
Console.WriteLine($"{num5} => {Math.Round(num5, MidpointRounding.ToNegativeInfinity)}");

Console.WriteLine("----------------Round with MidpointRounding.ToPositiveInfinity (ceiling) ---------------------");
Console.WriteLine($"{num1} => {Math.Round(num1, MidpointRounding.ToPositiveInfinity)}");
Console.WriteLine($"{num2} => {Math.Round(num2, MidpointRounding.ToPositiveInfinity)}");
Console.WriteLine($"{num3} => {Math.Round(num3, MidpointRounding.ToPositiveInfinity)}");
Console.WriteLine($"{num4} => {Math.Round(num4, MidpointRounding.ToPositiveInfinity)}");
Console.WriteLine($"{num5} => {Math.Round(num5, MidpointRounding.ToPositiveInfinity)}");

результат:

      ----------------Round with MidpointRounding.ToEven (default) ---------------------
1.5 => 2
2.5 => 2
3.5 => 4
2.51 => 3
2.48 => 2
----------------Round with MidpointRounding.AwayFromZero (mathematical rounding) ---------------------
1.5 => 2
2.5 => 3
3.5 => 4
2.51 => 3
2.48 => 2
----------------Round with MidpointRounding.ToZero ---------------------
1.5 => 1
2.5 => 2
3.5 => 3
2.51 => 2
2.48 => 2
----------------Round with MidpointRounding.ToNegativeInfinity ---------------------
1.5 => 1
2.5 => 2
3.5 => 3
2.51 => 2
2.48 => 2
----------------Round with MidpointRounding.ToPositiveInfinity ---------------------
1.5 => 2
2.5 => 3
3.5 => 4
2.51 => 3
2.48 => 3

user3405179 30 сен '17 в 10:52 2017-09-30 10:52 · Answer 14 · 2017-09-30 10:52

Math.Floor(123456.646 * 100) / 100 Возвращает 123456.64

2

Источник

user3405179 30 сен '17 в 10:52

user5275530 27 ноя '15 в 06:33 2015-11-27 06:33 · Answer 15 · 2015-11-27 06:33

Строка a = "10.65678";

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

1

Источник

user5275530 27 ноя '15 в 06:33

user1713519 28 июн '17 в 08:53 2017-06-28 08:53 · Answer 16 · 2017-06-28 08:53

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

0

Источник

user1713519 28 июн '17 в 08:53