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

Je veux le faire en utilisant la Math.Roundfonction

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 .

Essaye ça:

twoDec = Math.Round(val, 2)

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.

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.

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 ...

// 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"

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"

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)

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.

Une chose que vous voudrez peut-être vérifier est le mécanisme d'arrondi des mathématiques.

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

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

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 .

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

chaîne a = "10,65678";

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

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

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