Làm thế nào để bạn làm tròn một số đến hai chữ số thập phân trong C #?

Tôi muốn làm điều này bằng cách sử dụng Math.Roundchức năng

Dưới đây là một số ví dụ:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Bạn cũng có thể muốn xem xét các nhân viên ngân hàng làm tròn / làm tròn ngay cả với tình trạng quá tải sau đây:

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

Có thêm thông tin về nó ở đây .

Thử cái này:

twoDec = Math.Round(val, 2)

Cá nhân tôi không bao giờ làm tròn bất cứ điều gì. Giữ nó càng kiên quyết càng tốt, vì làm tròn là một chút cá trích đỏ trong CS nào. Nhưng bạn muốn định dạng dữ liệu cho người dùng của mình và cuối cùng, tôi thấy đó string.Format("{0:0.00}", number)là một cách tiếp cận tốt.

Nếu bạn thích một chuỗi

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

Hoặc một số thập phân

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

Nhưng hãy nhớ! Làm tròn không phải là phân phối, tức là. round(x*y) != round(x) * round(y). Vì vậy, đừng thực hiện bất kỳ làm tròn nào cho đến khi kết thúc phép tính, nếu không bạn sẽ mất độ chính xác.

Wikipedia có một trang đẹp về làm tròn nói chung.

Tất cả các ngôn ngữ .NET (được quản lý) có thể sử dụng bất kỳ cơ chế làm tròn thời gian chạy ngôn ngữ chung (CLR) nào. Ví dụ: phương thức Math.Round () (như đã đề cập ở trên) cho phép nhà phát triển chỉ định loại làm tròn (Làm tròn đến chẵn hoặc Xa từ 0). Phương thức Convert.ToInt32 () và các biến thể của nó sử dụng từ tròn đến chẵn . Các phương thức Trần () và Tầng () có liên quan.

Bạn có thể làm tròn với định dạng số tùy chỉnh là tốt.

Lưu ý rằng Decimal.Round () sử dụng một phương thức khác với Math.Round ();

Đây là một vị trí hữu ích trên thuật toán làm tròn của ngân hàng. Xem một trong những bài viết hài hước của Raymond ở đây về làm tròn ...

// chuyển đổi tối đa hai chữ số thập phân

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"

cũng có thể kết hợp "0" với "#".

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"

Tôi biết đó là một câu hỏi cũ nhưng xin lưu ý về những khác biệt sau đây giữa vòng Toán và vòng định dạng Chuỗi :

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"

Đây là để làm tròn đến 2 chữ số thập phân trong C #:

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

Trong VB.NET:

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

Nếu bạn muốn làm tròn một số, bạn có thể nhận được các kết quả khác nhau tùy thuộc vào: cách bạn sử dụng hàm Math.Round () (nếu làm tròn hoặc làm tròn), bạn đang làm việc với các số nhân và / hoặc số nổi và bạn áp dụng làm tròn điểm giữa. Đặc biệt, khi sử dụng với các thao tác bên trong nó hoặc biến thành vòng xuất phát từ một thao tác. Giả sử, bạn muốn nhân hai số này: 0,75 * 0,95 = 0,7125 . Đúng? Không có trong C #

Hãy xem điều gì xảy ra nếu bạn muốn làm tròn đến số thập phân thứ 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

Như bạn thấy, Vòng đầu tiên () là chính xác nếu bạn muốn làm tròn điểm giữa. Nhưng Vòng thứ hai () không đúng nếu bạn muốn làm tròn.

Điều này áp dụng cho số âm:

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

Vì vậy, IMHO, bạn nên tạo hàm bao bọc riêng cho Math.Round () phù hợp với yêu cầu của bạn. Tôi đã tạo một hàm trong đó, tham số 'roundUp = true' có nghĩa là làm tròn đến số lớn hơn tiếp theo. Đó là: 0,7125 vòng đến 0,713 và -0,7125 vòng đến -0,712 (vì -0,712> -0,713). Đây là chức năng tôi đã tạo và hoạt động cho bất kỳ số thập phân nào:

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

Biến 'hiệu chỉnh' là để sửa lỗi không chính xác khi vận hành với số nổi hoặc số kép.

Một điều bạn có thể muốn kiểm tra là Cơ chế làm tròn của Toán học.

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

Ngoài ra, tôi khuyên bạn nên sử dụng phương pháp Math.Round (inputNumer, numberOfPftime) so với * 100/100 vì nó sạch hơn.

Bạn sẽ có thể chỉ định số chữ số bạn muốn làm tròn để sử dụng Math.Round (YourNumber, 2)

Bạn có thể đọc thêm ở đây .

Math.Floor (123456.646 * 100) / 100 sẽ trả về 123456.64

chuỗi a = "10,65678";

thập phân d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

Có một tình huống kỳ lạ khi tôi có một biến thập phân, khi tuần tự hóa 55,50, nó luôn đặt giá trị mặc định theo toán học là 55,5. Nhưng trong khi đó, hệ thống khách hàng của chúng tôi thực sự mong đợi 55,50 vì một số lý do và họ chắc chắn mong đợi số thập phân. Đó là khi tôi đã viết trình trợ giúp bên dưới, nó luôn chuyển đổi bất kỳ giá trị thập phân nào được đệm thành 2 chữ số bằng số 0 thay vì gửi một chuỗi.

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

Cách sử dụng nên

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

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

Đầu ra:

2.50
2.00

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