Bagaimana Anda membulatkan angka ke dua tempat desimal di C #?

Saya ingin melakukan ini menggunakan Math.Roundfungsi

Inilah beberapa contoh:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Anda mungkin juga ingin melihat para bankir pembulatan / pembulatan hingga genap dengan kelebihan berikut:

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

Ada lebih banyak informasi di sini .

Coba ini:

twoDec = Math.Round(val, 2)

Secara pribadi saya tidak pernah membulatkan apapun. Pertahankan agar setegas mungkin, karena pembulatan adalah sedikit herring merah di CS. Tetapi Anda ingin memformat data untuk pengguna Anda, dan untuk itu, saya menemukan itu string.Format("{0:0.00}", number)adalah pendekatan yang baik.

Jika Anda ingin string

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

Atau desimal

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

Tapi ingat! Pembulatan tidak distributif, yaitu. round(x*y) != round(x) * round(y). Jadi, jangan lakukan pembulatan hingga penghitungan, karena Anda akan kehilangan keakuratan

Wikipedia memiliki halaman yang bagus tentang pembulatan secara umum.

Semua bahasa .NET (terkelola) dapat menggunakan mekanisme pembulatan waktu berjalan bahasa umum (CLR). Sebagai contoh, metode Math.Round () (seperti yang disebutkan di atas) memungkinkan pengembang untuk menentukan jenis pembulatan (Round-to-even atau Away-from-zero). Metode Convert.ToInt32 () dan variasinya menggunakan round-to-even . Metode Ceiling () dan Floor () saling terkait.

Anda juga dapat membulatkannya dengan pemformatan angka khusus .

Perhatikan bahwa Decimal.Round () menggunakan metode yang berbeda dari Math.Round ();

Berikut ini adalah posisi yang berguna pada algoritma pembulatan bankir. Lihat salah satu postingan lucu Raymond di sini tentang pembulatan ...

// konversi hingga dua tempat desimal

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"

juga dapat menggabungkan "0" dengan "#".

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"

Saya tahu ini pertanyaan lama, tetapi harap perhatikan perbedaan berikut antara putaran Math dan putaran format 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"

Ini untuk pembulatan ke 2 tempat desimal di C #:

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

Di VB.NET:

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

Jika Anda ingin membulatkan angka, Anda bisa mendapatkan hasil yang berbeda tergantung pada: bagaimana Anda menggunakan fungsi Math.Round () (jika untuk pembulatan ke atas atau ke bawah), Anda bekerja dengan angka gandeng dan / atau mengapung , dan Anda menerapkan pembulatan titik tengah. Terutama, ketika menggunakan dengan operasi di dalamnya atau variabel ke putaran berasal dari operasi. Katakanlah, Anda ingin mengalikan dua angka ini: 0,75 * 0,95 = 0,7125 . Baik? Tidak dalam C #

Mari kita lihat apa yang terjadi jika Anda ingin membulatkan ke desimal ke-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

Seperti yang Anda lihat, Putaran pertama () benar jika Anda ingin membulatkan titik tengah. Tapi Babak kedua () itu salah jika Anda ingin mengumpulkan.

Ini berlaku untuk angka negatif:

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

Jadi, IMHO, Anda harus membuat fungsi wrap sendiri untuk Math.Round () yang sesuai dengan kebutuhan Anda. Saya membuat fungsi di mana, parameter 'roundUp = true' berarti untuk membulatkan ke angka yang lebih besar berikutnya. Yaitu: 0,7125 putaran ke 0,713 dan -0,7125 putaran ke -0,712 (karena -0,712> -0,713). Ini adalah fungsi yang saya buat dan bekerja untuk sejumlah desimal:

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

'Korektor' variabel adalah untuk memperbaiki ketidaktepatan operasi dengan angka mengambang atau ganda.

Satu hal yang mungkin ingin Anda periksa adalah Mekanisme Pembulatan Matematika. Putaran:

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

Selain itu, saya merekomendasikan pendekatan Math.Round (inputNumer, numberOfPlaces) lebih dari * 100/100 karena lebih bersih.

Anda harus dapat menentukan jumlah digit yang ingin Anda bulatkan dengan menggunakan Math.Round (YourNumber, 2)

Anda dapat membaca lebih lanjut di sini .

Math.Floor (123456.646 * 100) / 100 Akan mengembalikan 123456.64

string a = "10.65678";

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

Punya situasi aneh di mana saya memiliki variabel desimal, ketika membuat serial 55.50 selalu menetapkan nilai default secara matematis sebagai 55.5. Tetapi sementara itu, sistem klien kami secara serius mengharapkan 55,50 untuk beberapa alasan dan mereka pasti mengharapkan desimal. Thats ketika saya telah menulis pembantu di bawah ini, yang selalu mengubah nilai desimal apa pun yang empuk menjadi 2 digit dengan nol daripada mengirim string.

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

Penggunaan seharusnya

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

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

Keluaran:

2.50
2.00

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