web-dev-qa-db-fra.com

Comment arrondir un nombre à deux décimales près en C #?

Je veux faire cela en utilisant la fonction Math.Round

c#decimalroundingbankers-rounding
339
Laila

Voici quelques exemples:

decimal a = 1.994444M;

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

decimal b = 1.995555M;

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

Vous voudrez peut-être également examiner les banquiers arrondis/arrondis avec la surcharge suivante:

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

Il y a plus d'informations à ce sujet ici .

574
Eoin Campbell

Essaye ça:

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

Personnellement je n’arrête jamais rien. Gardez-le aussi résolu que possible, car l'arrondir est un peu un piège rouge dans CS de toute façon. Mais vous voulez formater les données pour vos utilisateurs, et à cette fin, je trouve que string.Format("{0:0.00}", number) est une bonne approche.

33
Gleno

Si vous voulez une ficelle

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

Ou une décimale

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

Mais rappelles-toi! L'arrondissement n'est pas distributif, c'est-à-dire. round(x*y) != round(x) * round(y). Donc, ne faites pas d'arrondissement jusqu'à la fin d'un calcul, sinon vous perdrez en précision.

29
Colonel Panic

// convertir jusqu'à deux décimales

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"

peut également combiner "0" avec "#".

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 a une page Nice sur l'arrondi en général.

Tous les langages .NET (gérés) peuvent utiliser n'importe quel mécanisme d'arrondi du langage d'exécution courant (CLR). Par exemple, la méthode Math.Round () (comme indiqué ci-dessus) permet au développeur de spécifier le type d'arrondi (arrondi au niveau ou égal à zéro). La méthode Convert.ToInt32 () et ses variantes utilisent round-to-even . Les méthodes Ceiling () et Floor () sont liées.

Vous pouvez également arrondir avec mise en forme numérique personnalisée .

Notez que Decimal.Round () utilise une méthode différente de Math.Round ();

Voici un tile pos t sur l'algorithme d'arrondi du banquier. Voir l'un des humoristiques de Raymond messages ici à propos d'arrondi ...

12
Foredecker

Je sais que c’est une vieille question, mais veuillez noter les différences suivantes entre Math round et 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

C'est pour arrondir à 2 décimales en C #:

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

En VB.NET:

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

Une chose que vous voudrez peut-être vérifier est le mécanisme d'arrondi de Math.Round:

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

En dehors de cela, je recommande l'approche Math.Round (inputNumer, numberOfPlaces) par rapport à * 100/100 car elle est plus propre.

4
Michael Stum

Vous devriez pouvoir spécifier le nombre de chiffres que vous souhaitez arrondir à l'aide de Math.Round (YourNumber, 2).

Vous pouvez en lire plus ici .

3
Kevin W Lee

chaîne a = "10.65678";

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

1
Abhishek Jaiswal

Si vous voulez arrondir un nombre, vous pouvez obtenir différents résultats en fonction de: comment vous utilisez la fonction Math.Round () (si vous voulez arrondir ou arrondir), vous travaillez avec des nombres doubles et/ou flottants. et vous appliquez l’arrondi du milieu. En particulier, lorsque vous utilisez avec des opérations à l'intérieur de celle-ci ou que la variable à arrondir provient d'une opération. Disons que vous voulez multiplier ces deux nombres: .75 * 0.95 = 0.7125. Droite? Pas en C #

Voyons ce qui se passe si vous voulez arrondir à la 3ème décimale:

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

Comme vous le voyez, le premier round () est correct si vous voulez arrondir le point central. Mais le second tour () est faux si vous voulez arrondir.

Ceci s'applique aux nombres négatifs:

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

Donc, à mon humble avis, vous devez créer votre propre fonction d’emballage pour Math.Round () qui correspond à vos besoins. J'ai créé une fonction dans laquelle le paramètre 'roundUp = true' signifie arrondir au nombre suivant. C'est-à-dire que 0,7125 arrondit à 0,713 et -0,7125 arrondit à -0,712 (car -0,712> -0,713). C’est la fonction que j’ai créée et qui fonctionne pour n’importe quel nombre de décimales:

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

La variable 'correcteur' sert à corriger l'inexactitude de fonctionnement avec des nombres flottants ou des nombres doubles.

1
fedesanp

Math.Floor (123456.646 * 100)/1 Retournerait 123456.64

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