Comment arrondir une valeur décimale à 2 décimales (pour une sortie sur une page)

je sais que c'est une vieille question, mais j'ai été surpris de voir que personne ne semblait répondre que;

1. N'utilisez pas les banquiers arrondissement
2. N'a pas gardé la valeur décimale.

C'est ce que j'utiliserais:

decimal.Round(yourValue, 2, MidpointRounding.AwayFromZero);

http://msdn.microsoft.com/en-us/library/9s0xa85y.aspx

decimalVar.ToString("F");

Ce sera:

• arrondir à 2 décimales p. ex. 23.456 = > 23.46
• veiller à ce qu'il sont toujours 2 décimales par exemple. 23 => 23.00, 12.5 => 12.50

Idéal pour de la monnaie et de l'affichage des montants monétaires.

pour la documentation sur ToString ("F"): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatString (avec remerciements à Jon Schneider)

si vous avez juste besoin de cela pour l'affichage utilisez string.Format

String.Format("{0:0.00}", 123.4567m);      // "123.46"

http://www.csharp-examples.net/string-format-double /

le " m " est un suffixe décimal. À propos du suffixe décimal:

http://msdn.microsoft.com/en-us/library/364x0z75.aspx

Donné décimal d=12.345; les expressions d.ToString("C") ou de la Chaîne.Format ("{0: C}", d) yield 12,35 $ - notez que les paramètres de devise de la culture courante incluant le symbole sont utilisés.

noter que C " utilise le nombre de chiffres de la culture courante. Vous pouvez toujours outrepasser par défaut pour forcer la précision nécessaire avec C{Precision specifier} comme String.Format("{0:C2}", 5.123d) .

si vous voulez qu'il soit formaté avec des virgules ainsi qu'un point décimal (mais pas de symbole de devise), comme 3,456,789.12...

decimalVar.ToString("n2");

il y a déjà deux bonnes réponses qui font référence à la décimale.Rond.(..) mais je pense qu'un peu plus d'explication est nécessaire - parce qu'Il ya une propriété importante inattendue de décimale qui n'est pas évident.

une décimale' sait ' combien de décimales elle a basé sur son origine.

par exemple ce qui suit peut être inattendu :

Decimal.Parse("25").ToString()          =>   "25"
Decimal.Parse("25.").ToString()         =>   "25"
Decimal.Parse("25.0").ToString()        =>   "25.0"
Decimal.Parse("25.0000").ToString()     =>   "25.0000"

25m.ToString()                          =>   "25"
25.000m.ToString()                      =>   "25.000"

faire les mêmes opérations avec Double ne pas indiquer de décimale ( "25" ) pour chacune des réponses ci-dessus.

quand vous voulez une décimale à 2 décimales theres environ une chance de 95% c'est parce que c'est monnaie dans ce cas, ce qui est probablement bien pour 95% du temps:

Decimal.Parse("25.0").ToString("c")     =>   ".00"

ou dans XAML vous venez d'utiliser {Binding Price, StringFormat=c}

J'ai rencontré un cas où j'avais besoin d'une décimale en tant que décimale lors de l'envoi de XML au service Web D'Amazon. Le service se plaignait parce qu'un La valeur décimale (à l'origine de SQL Server) était envoyée comme 25.1200 et rejetée, ( 25.12 était le format attendu).

Tout ce que j'avais à faire était Decimal.Round(...) avec 2 décimales pour corriger le problème.

 // This is an XML message - with generated code by XSD.exe
 StandardPrice = new OverrideCurrencyAmount()
 {
       TypedValue = Decimal.Round(product.StandardPrice, 2),
       currency = "USD"
 }

TypedValue est de type Decimal donc je ne pouvais pas juste faire ToString("N2") et nécessaire pour le compléter et de le conserver comme un decimal .

voici un petit programme Linqpad pour afficher différents formats:

void Main()
{
    FormatDecimal(2345.94742M);
    FormatDecimal(43M);
    FormatDecimal(0M);
    FormatDecimal(0.007M);
}

public void FormatDecimal(decimal val)
{
    Console.WriteLine("ToString: {0}", val);
    Console.WriteLine("c: {0:c}", val);
    Console.WriteLine("0.00: {0:0.00}", val);
    Console.WriteLine("0.##: {0:0.##}", val);
    Console.WriteLine("===================");
}

Voici les résultats:

ToString: 2345.94742
c: ,345.95
0.00: 2345.95
0.##: 2345.95
===================
ToString: 43
c: .00
0.00: 43.00
0.##: 43
===================
ToString: 0
c: "151910920".00
0.00: 0.00
0.##: 0
===================
ToString: 0.007
c: "151910920".01
0.00: 0.01
0.##: 0.01
===================

"151910920 des Mathématiques".Méthode Ronde (Décimale, Int32)

aucun de ceux-ci n'a fait exactement ce dont j'avais besoin, pour forcer 2 D. p. et arrondir à 0.005 -> 0.01

forçant 2 D. p. nécessite d'augmenter la précision de 2 D. p. pour s'assurer que nous avons au moins 2 D. p.

puis arrondissement pour s'assurer que nous n'avons pas plus de 2 D. p.

Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero)

6.665m.ToString() -> "6.67"

6.6m.ToString() -> "6.60"

vous pouvez utiliser le système.mondialisation formater un numéro dans n'importe quel format requis.

par exemple:

system.globalization.cultureinfo ci = new system.globalization.cultureinfo("en-ca");

si vous avez un decimal d = 1.2300000 et que vous avez besoin de le couper à 2 décimales, alors il peut être imprimé comme ceci d.Tostring("F2",ci); où F2 est chaîne de caractères formant à 2 décimales et ci est la locale ou cultureinfo.

pour plus d'informations, consultez ce lien

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

Le top-rated réponse décrit une méthode pour la mise en forme de la représentation de chaîne de la valeur décimale, et il fonctionne.

Cependant, si vous souhaitez réellement changer la précision enregistrés à la valeur réelle, vous devez écrire quelque chose comme:

public static class PrecisionHelper
{
    public static decimal TwoDecimalPlaces(this decimal value)
    {
        // These first lines eliminate all digits past two places.
        var timesHundred = (int) (value * 100);
        var removeZeroes = timesHundred / 100m;

        // In this implementation, I don't want to alter the underlying
        // value.  As such, if it needs greater precision to stay unaltered,
        // I return it.
        if (removeZeroes != value)
            return value;

        // Addition and subtraction can reliably change precision.  
        // For two decimal values A and B, (A + B) will have at least as 
        // many digits past the decimal point as A or B.
        return removeZeroes + 0.01m - 0.01m;
    }
}

essai d'une unité témoin:

[Test]
public void PrecisionExampleUnitTest()
{
    decimal a = 500m;
    decimal b = 99.99m;
    decimal c = 123.4m;
    decimal d = 10101.1000000m;
    decimal e = 908.7650m

    Assert.That(a.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("500.00"));

    Assert.That(b.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("99.99"));

    Assert.That(c.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("123.40"));

    Assert.That(d.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("10101.10"));

    // In this particular implementation, values that can't be expressed in
    // two decimal places are unaltered, so this remains as-is.
    Assert.That(e.TwoDecimalPlaces().ToString(CultureInfo.InvariantCulture),
        Is.EqualTo("908.7650"));
}

très rarement vous voulez une chaîne vide si la valeur est 0.

decimal test = 5.00;
test.ToString("0.00");  //"5.00"
decimal? test2 = 5.05;
test2.ToString("0.00");  //"5.05"
decimal? test3 = 0;
test3.ToString("0.00");  //"0.00"

la réponse la mieux cotée est incorrecte et a gaspillé 10 minutes de (la plupart) le temps des gens.

https://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx

Ce lien qui explique en détail comment vous pouvez traiter votre problème et ce que vous pouvez faire si vous voulez en savoir plus. Pour des raisons de simplicité, ce que vous voulez faire est

double whateverYouWantToChange = whateverYouWantToChange.ToString("F2");

si vous voulez cela pour une devise, vous pouvez le rendre plus facile en tapant "C2" au lieu de" F2 "

la réponse de Mike M. était parfaite pour moi sur .NET, mais .net Core n'a pas de méthode decimal.Round au moment de la rédaction.

dans .net Core, j'ai dû utiliser:

decimal roundedValue = Math.Round(rawNumber, 2, MidpointRounding.AwayFromZero);

une méthode hacky, y compris la conversion en chaîne, est:

public string FormatTo2Dp(decimal myNumber)
{
    // Use schoolboy rounding, not bankers.
    myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero);

    return string.Format("{0:0.00}", myNumber);
}