it-swarm.com.de

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

Ich möchte dies mit der Funktion Math.Round tun

339
Laila

Hier sind einige Beispiele:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Möglicherweise möchten Sie sich auch Banker ansehen, die mit der folgenden Überladung auf- oder abgerundet werden:

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

Es gibt mehr Informationen darüber hier .

574
Eoin Campbell

Versuche dies:

twoDec = Math.Round(val, 2)
87
John Boker

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 string.Format("{0:0.00}", number) für einen guten Ansatz.

33
Gleno

Wenn Sie eine Zeichenfolge möchten

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

Oder eine Dezimalstelle

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

Aber erinnere dich! Die Rundung ist nicht verteilend, dh. round(x*y) != round(x) * round(y). Runden Sie also erst ganz am Ende einer Berechnung, da Sie sonst an Genauigkeit verlieren.

29
Colonel Panic

// 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"
13
Rae Lee

Wikipedia hat eine nette Seite Rundung allgemein.

Alle .NET-Sprachen (verwaltete Sprachen) können beliebige Rundungsmechanismen der Common Language Run Time (CLR) verwenden. Mit der Methode Math.Round () (wie oben erwähnt) kann der Entwickler beispielsweise die Art der Rundung angeben (aufgerundet oder von Null entfernt). Die Convert.ToInt32 () -Methode und ihre Variationen verwenden rund bis gerade . Die Methoden Ceiling () und Floor () sind verwandt.

Sie können auch mit benutzerdefinierte numerische Formatierung runden.

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

Hier ist ein nützliche Position t für den Rundungsalgorithmus des Bankiers. Sehen Sie einen von Raymonds humorvollen Posts hier über das Runden ...

12
Foredecker

Ich weiß, dass es eine alte Frage ist, aber bitte beachten Sie die folgenden Unterschiede zwischen Math round und String format round:

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
Guy

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)
5
sadim

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

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

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

4
Michael Stum

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

Sie können mehr lesen hier .

3
Kevin W Lee

string a = "10.65678";

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

1

Wenn Sie eine Zahl runden möchten, können Sie unterschiedliche Ergebnisse erhalten, je nachdem, wie Sie die Funktion Math.Round () verwenden (ob für eine Rundung oder Abrundung), Sie arbeiten mit doppelten und/oder Gleitkommazahlen und Sie wenden die Mittelpunktrundung an. Insbesondere, wenn mit Operationen innerhalb davon gearbeitet wird oder die zu rundende Variable aus einer Operation stammt. Angenommen, Sie möchten diese beiden Zahlen multiplizieren: ,75 * 0,95 = 0,7125. Richtig? 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 () richtig, wenn Sie den Mittelpunkt abrunden möchten. Aber die zweite Runde () ist 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ächsthöhere 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 zum Korrigieren der Ungenauigkeit beim Arbeiten mit Gleitkomma- oder Doppelnummern.

1
fedesanp

Math.Floor (123456.646 * 100)/1 Gibt 123456.64 zurück

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