Wie runden Sie eine Zahl auf zwei Dezimalstellen in C#?

Question

Ich möchte dies mit Hilfe des Math.Round Funktion

Answer 1

// Umrechnung bis zu zwei Dezimalstellen

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"

kann auch "0" mit "#" kombiniert werden.

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"

Answer 2

Wenn Sie eine Zahl runden wollen, können Sie unterschiedliche Ergebnisse erzielen, je nachdem, wie Sie die Funktion Math.Round() verwenden (ob Sie auf- oder abrunden wollen), ob Sie mit Doppel- und/oder Fließkommazahlen arbeiten und ob Sie die Mittelpunktsrundung anwenden. Vor allem, wenn Sie die Funktion mit darin enthaltenen Operationen verwenden oder die zu rundende Variable aus einer Operation stammt. Nehmen wir an, Sie wollen diese beiden Zahlen multiplizieren: 0.75 * 0.95 = 0.7125 . Oder? Nicht in C#

Sehen wir uns an, was passiert, wenn man auf die 3. Dezimalstelle runden will:

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

Wie Sie sehen, ist das erste Round() richtig, wenn Sie den Mittelpunkt abrunden wollen. Aber das zweite Round() ist falsch, wenn Sie aufrunden wollen.

Dies gilt für negative Zahlen:

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 sollten Sie also eine eigene Umhüllungsfunktion für Math.Round() erstellen, die Ihren Anforderungen entspricht. Ich habe eine Funktion erstellt, bei der der Parameter 'roundUp=true' bedeutet, dass auf die nächstgrößere Zahl gerundet wird. Das heißt: 0.7125 rundet auf 0.713 und -0.7125 rundet auf -0.712 (weil -0.712 > -0.713). Diese Funktion habe ich erstellt und sie funktioniert für jede Anzahl von Dezimalstellen:

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

Die Variable "corrector" dient dazu, die Ungenauigkeit bei der Arbeit mit Gleitkomma- oder Doppelzahlen zu beheben.

Answer 3

Dies ist für die Rundung auf 2 Dezimalstellen in C#:

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

In VB.NET:

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

Answer 4

Ich weiß, es ist eine alte Frage, aber bitte beachten Sie die folgenden Unterschiede zwischen Mathe-Runde y String-Format rund :

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"

Answer 5

Ich hatte eine seltsame Situation, in der ich eine Dezimalvariable hatte, die bei der Serialisierung von 55,50 immer den Standardwert mathematisch als 55,5 setzt. Unser Kundensystem erwartet jedoch aus irgendeinem Grund 55,50, und es erwartet definitiv eine Dezimalzahl. Daraufhin habe ich den folgenden Helfer geschrieben, der jeden Dezimalwert, der auf 2 Stellen mit Nullen aufgefüllt wird, umwandelt, anstatt einen String zu senden.

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

Die Verwendung sollte sein

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

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

Ausgabe:

2.50
2.00