Comment arrondissez-vous un nombre à deux décimales en C #?

Réponses:

629

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 pouvez également regarder les banquiers arrondis / arrondis à égal avec la surcharge suivante:

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

Il y a plus d'informations ici .

Eoin Campbell
la source
51
Vous devez préciser que MidPointRounding.ToEven EST la valeur par défaut. Si vous vouliez AwayFromZero, vous devriez utiliser la surcharge
Brian Vander Plaats
5
Si vous souhaitez arrondir jusqu'à 2 décimales, ajoutez- 0.005le avant l'arrondi. De même pour arrondir vers le bas , soustraire 0.005avant de passer à la Math.Roundfonction.
orad
4
La raison pour laquelle .NET est par défaut MidPointRounding.ToEven(aka "Bankers Rounding") est parce que nous avons tous appris à arrondir à l'école où .5 arrondis provoque trop d'arrondis. C'est un problème lorsqu'il s'agit d'argent, de calculs fiscaux, etc.
asporter
97

Essaye ça:

twoDec = Math.Round(val, 2)
John Boker
la source
33

Personnellement, je n'ai jamais rien arrondi. Gardez-le aussi résolu que possible, car l'arrondi est un peu un hareng 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)c'est une bonne approche.

Gleno
la source
Cela fonctionne mieux à des fins d'affichage, en particulier pour de l'argent, car 5,4 £ (avec Math.round) ne semblent pas aussi bien que 5,40 £ (de cette façon).
Peter Gordon
J'ai essayé avant string.Format ("0: 0.00", nombre), mais cela n'a pas fonctionné. Ces crochets sont très importants, donc: string.Format ("{0: 0.00}", number) fonctionne.
FrenkyB
8
@FrenkyB Lorsque vous dites "crochets", j'espère que vous voulez dire accolades.
Mathemats
Cette ronde aussi. 1,009 => 1,01
Donny V.
30

Si vous souhaitez une chaîne

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

Ou une décimale

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

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

Colonel Panic
la source
14

Wikipedia a une belle page 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 commun (CLR). Par exemple, la méthode Math.Round () (comme mentionné ci-dessus) permet au développeur de spécifier le type d'arrondi (Arrondi à égal ou Absent de zéro). La méthode Convert.ToInt32 () et ses variantes utilisent l' arrondi en pair . Les méthodes Ceiling () et Floor () sont liées.

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

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

Voici une position utile sur l'algorithme d'arrondi du banquier. Voir l'un des articles humoristiques de Raymond ici sur l'arrondissement ...

Foredecker
la source
13

// 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"
Rae Lee
la source
1
String.Format ("{0: 0,00}", 140,6767554); ! = "140.67" Le rendu est en fait "140.68" - arrondi
AndyT
7

Je sais que c'est une vieille question, mais veuillez noter les différences suivantes entre le tour Math et le tour de 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"
Guy P
la source
6

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

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

Dans VB.NET:

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

Si vous voulez arrondir un nombre, vous pouvez obtenir des résultats différents selon: la façon dont vous utilisez la fonction Math.Round () (si pour un arrondi ou un arrondi), vous travaillez avec des nombres doubles et / ou flottants et vous appliquez l'arrondi au milieu. Surtout, lors de l'utilisation avec des opérations à l'intérieur de celle-ci ou la variable à arrondir provient d'une opération. Disons que vous voulez multiplier ces deux nombres: 0,75 * 0,95 = 0,7125 . Droite? Pas en C #

Voyons ce qui se passe si vous voulez arrondir à la 3e 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 milieu. Mais le deuxième Round () c'est faux si vous voulez arrondir.

Cela 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'habillage pour Math.Round () qui correspond à vos besoins. J'ai créé une fonction dans laquelle, le paramètre 'roundUp = true' signifie arrondir au nombre supérieur suivant. Soit: 0,7125 rounds à 0,713 et -0,7125 rounds à -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 du fonctionnement avec des nombres flottants ou doubles.

fedesanp
la source
3

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

Vous pouvez en lire plus ici .

Kevin W Lee
la source
2

Math.Floor (123456.646 * 100) / 100 retournerait 123456.64

user3405179
la source
1

chaîne a = "10,65678";

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

Abhishek Jaiswal
la source
1

Dans une situation étrange où j'avais une variable décimale, lors de la sérialisation de 55,50, elle définit toujours la valeur par défaut mathématiquement comme 55,5. Mais alors, notre système client attend sérieusement 55,50 pour une raison quelconque et ils s'attendaient certainement à la décimale. C'est quand j'ai écrit l'aide ci-dessous, qui convertit toujours toute valeur décimale complétée en 2 chiffres avec des zéros au lieu d'envoyer une chaîne.

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

L'utilisation doit être

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

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

Production:

2.50
2.00
Riyaz Hameed
la source
0
  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }
Ruan
la source