Wie rundet man eine Zahl in C # auf zwei Dezimalstellen?

Ich möchte dies mit der Math.RoundFunktion tun

Hier einige Beispiele:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Vielleicht möchten Sie auch Banker betrachten, die sich mit der folgenden Überlastung runden / abrunden:

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

Weitere Informationen dazu finden Sie hier .

Versuche dies:

twoDec = Math.Round(val, 2)

Persönlich runde ich nie etwas. Halten Sie es so entschlossen wie möglich, da das Runden in CS sowieso ein bisschen wie ein roter Hering ist. Sie möchten jedoch Daten für Ihre Benutzer formatieren, und zu diesem Zweck halte ich dies für string.Format("{0:0.00}", number)einen guten Ansatz.

Wenn Sie eine Zeichenfolge möchten

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

Oder eine Dezimalstelle

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

Aber erinnere dich! Rundung ist nicht verteilend, dh. round(x*y) != round(x) * round(y). Machen Sie also bis zum Ende einer Berechnung keine Rundung, sonst verlieren Sie an Genauigkeit.

Wikipedia hat eine schöne Seite zum Runden im Allgemeinen.

Alle (verwalteten) .NET-Sprachen können einen der CLR-Rundungsmechanismen (Common Language Runtime) verwenden. Mit der Math.Round () -Methode ( wie oben erwähnt) kann der Entwickler beispielsweise die Art der Rundung angeben (Round-to-Even oder Away-from-Zero). Die Convert.ToInt32 () -Methode und ihre Variationen verwenden Round-to-Even . Die Methoden Ceiling () und Floor () sind miteinander verbunden.

Sie können auch mit benutzerdefinierten numerischen Formatierungen runden .

Beachten Sie, dass Decimal.Round () eine andere Methode verwendet als Math.Round ().

Hier ist eine nützliche Position zum Rundungsalgorithmus des Bankiers. Sehen Sie hier einen von Raymonds humorvollen Posts über Rundungen ...

// konvertiere 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 "#" kombinieren.

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"

Ich weiß, dass es eine alte Frage ist, aber bitte beachten Sie die folgenden Unterschiede zwischen der Math-Runde und der String-Format-Runde :

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"

Dies dient zum Runden auf 2 Dezimalstellen in C #:

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

In VB.NET:

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

Wenn Sie eine Zahl runden möchten, können Sie unterschiedliche Ergebnisse erzielen, je nachdem: wie Sie die Math.Round () -Funktion verwenden (wenn Sie eine Auf- oder Abrundung durchführen), arbeiten Sie mit doppelten und / oder schwebenden Zahlen und Sie wenden die Mittelpunktsrundung an. Insbesondere bei Verwendung mit darin enthaltenen Operationen oder der zu rundenden Variablen stammt sie aus einer Operation. Angenommen , Sie möchten diese beiden Zahlen multiplizieren: 0,75 * 0,95 = 0,7125 . Recht? Nicht in C #

Mal sehen, was passiert, wenn Sie auf die 3. Dezimalstelle runden möchten:

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 die erste Runde () korrekt, wenn Sie den Mittelpunkt abrunden möchten. Aber in der zweiten Runde () ist es falsch, wenn Sie aufrunden möchten.

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

Also, IMHO, sollten Sie Ihre eigene Wrap-Funktion für Math.Round () erstellen, die Ihren Anforderungen entspricht. Ich habe eine Funktion erstellt, in der der Parameter 'roundUp = true' bedeutet, auf die nächstgrößere Zahl zu runden. Das heißt: 0,7125 Runden auf 0,713 und -0,7125 Runden auf -0,712 (weil -0,712> -0,713). Dies ist die Funktion, die ich erstellt habe und die für eine beliebige Anzahl von Dezimalstellen funktioniert:

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 'Korrektor' dient dazu, die Ungenauigkeit des Betriebs mit schwebenden oder doppelten Zahlen zu beheben.

Eine Sache, die Sie überprüfen möchten, ist der Rundungsmechanismus von Math.Round:

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

Abgesehen davon empfehle ich den Math.Round-Ansatz (inputNumer, numberOfPlaces) gegenüber dem * 100/100 -Ansatz, da er sauberer ist.

Sie sollten in der Lage sein, die Anzahl der Stellen anzugeben, auf die Sie mit Math.Round (YourNumber, 2) runden möchten.

Sie können mehr lesen hier .

Math.Floor (123456.646 * 100) / 100 würde 123456.64 zurückgeben

Zeichenfolge a = "10.65678";

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

Hatte eine seltsame Situation, in der ich eine Dezimalvariable hatte. Bei der Serialisierung von 55.50 wird der Standardwert mathematisch immer auf 55.5 gesetzt. Unser Client-System erwartet jedoch aus irgendeinem Grund ernsthaft 55,50 und definitiv Dezimalzahlen. Das war, als ich den folgenden Helfer geschrieben hatte, der immer jeden aufgefüllten Dezimalwert in 2 Ziffern mit Nullen konvertiert, anstatt eine Zeichenfolge zu senden.

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

Verwendung sollte sein

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

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

Ausgabe:

2.50
2.00

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