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

 decimalVar.ToSsortingng ("#.##"); // returns "" when decimalVar == 0 

ou

 decimalVar.ToSsortingng ("0.##"); // returns "0" when decimalVar == 0 

Je sais que c’est une vieille question, mais j’ai été surpris de voir que personne ne semblait poster une réponse.

1. N’a pas utilisé les banquiers
2. N’a pas conservé la valeur sous forme décimale.

C’est ce que j’utiliserais:

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

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

 decimalVar.ToSsortingng("F"); 

Cette volonté:

• Arrondissez à 2 décimales, par exemple. 23,456 => 23,46
• Assurez-vous qu’il y a toujours 2 décimales, par exemple. 23 => 23,00, 12,5 => 12,50

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

Pour la documentation sur ToSsortingng (“F”): http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx#FFormatSsortingng (avec merci à Jon Schneider)

Si vous avez juste besoin de ceci pour l’affichage, utilisez ssortingng.Format

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

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

Le “m” est un suffixe décimal. À propos du suffixe décimal:

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

Compte tenu de la décimale d = 12,345; les expressions d.ToSsortingng (“C”) ou Ssortingng.Format (“{0: C}”, d) rapportent 12,35 $ – notez que les parameters de devise de la culture actuelle, y compris le symbole, sont utilisés.

Notez que “C” utilise le nombre de chiffres de la culture actuelle. Vous pouvez toujours remplacer la valeur par défaut pour forcer la précision nécessaire avec C{Precision specifier} comme Ssortingng.Format("{0:C2}", 5.123d) .

Si vous le souhaitez au format avec des virgules et un point décimal (mais pas de symbole monétaire), par exemple 3,456,789.12 …

 decimalVar.ToSsortingng("n2"); 

Il y a déjà deux réponses à haute notation qui se réfèrent à Decimal.Round (…) mais je pense qu’un peu plus d’explication est nécessaire – car il y a une propriété importante inattendue de Decimal qui n’est pas évidente.

Un nombre décimal «sait» le nombre de décimales dont il est basé.

Par exemple, les éléments suivants peuvent être inattendus:

 Decimal.Parse("25").ToSsortingng() => "25" Decimal.Parse("25.").ToSsortingng() => "25" Decimal.Parse("25.0").ToSsortingng() => "25.0" Decimal.Parse("25.0000").ToSsortingng() => "25.0000" 25m.ToSsortingng() => "25" 25.000m.ToSsortingng() => "25.000" 

Faire les mêmes opérations avec Double ne donnera aucune décimale ( "25" ) pour chacun des points ci-dessus.

Lorsque vous voulez une décimale à 2 décimales, il y a environ 95% de chances que ce soit parce que c’est la devise, auquel cas c’est probablement correct pour 95% du temps:

 Decimal.Parse("25.0").ToSsortingng("c") => "$25.00" 

Ou dans XAML, vous utilisez juste {Binding Price, SsortingngFormat=c}

Un cas que j’ai rencontré où j’avais besoin d’une décimale AS était une décimale lors de l’envoi de XML au service Web d’Amazon. Le service se plaignait car une valeur décimale (à l’origine de SQL Server) était envoyée en tant que 25.1200 et rejetée (le format attendu était 25.1200 ).

Tout ce que j’avais à faire était Decimal.Round(...) avec 2 décimales pour résoudre 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 faire simplement ToSsortingng("N2") et je devais l’arrondir et le conserver sous forme decimal .

Voici un petit programme Linqpad pour montrer différents formats:

 void Main() { FormatDecimal(2345.94742M); FormatDecimal(43M); FormatDecimal(0M); FormatDecimal(0.007M); } public void FormatDecimal(decimal val) { Console.WriteLine("ToSsortingng: {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:

 ToSsortingng: 2345.94742 c: $2,345.95 0.00: 2345.95 0.##: 2345.95 =================== ToSsortingng: 43 c: $43.00 0.00: 43.00 0.##: 43 =================== ToSsortingng: 0 c: $0.00 0.00: 0.00 0.##: 0 =================== ToSsortingng: 0.007 c: $0.01 0.00: 0.01 0.##: 0.01 =================== 

Méthode Math.Round (Decimal, Int32)

Aucun de ceux-ci n’a fait exactement ce dont j’avais besoin pour forcer 2 dp et arrondir à 0.005 -> 0.01

Forcer 2 dp nécessite d’augmenter la précision de 2 dp pour avoir au moins 2 dp

puis arrondir pour ne pas avoir plus de 2 dp

 Math.Round(exactResult * 1.00m, 2, MidpointRounding.AwayFromZero) 6.665m.ToSsortingng() -> "6.67" 6.6m.ToSsortingng() -> "6.60" 

Vous pouvez utiliser system.globalization pour formater un nombre dans n’importe quel format requirejs.

Par exemple:

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

Si vous avez un nombre decimal d = 1.2300000 et que vous devez le couper à 2 décimales, il peut être imprimé comme ceci d.Tossortingng("F2",ci); où F2 est une chaîne formant 2 décimales et ci est la locale ou cultureinfo.

pour plus d’infos consultez ce lien
http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx

La réponse la mieux classée décrit une méthode de formatage de la représentation sous forme de chaîne de la valeur décimale, et elle fonctionne.

Toutefois, si vous souhaitez réellement modifier la précision enregistrée sur la valeur réelle, vous devez écrire quelque chose comme ceci:

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

Un exemple de test unitaire:

 [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().ToSsortingng(CultureInfo.InvariantCulture), Is.EqualTo("500.00")); Assert.That(b.TwoDecimalPlaces().ToSsortingng(CultureInfo.InvariantCulture), Is.EqualTo("99.99")); Assert.That(c.TwoDecimalPlaces().ToSsortingng(CultureInfo.InvariantCulture), Is.EqualTo("123.40")); Assert.That(d.TwoDecimalPlaces().ToSsortingng(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().ToSsortingng(CultureInfo.InvariantCulture), Is.EqualTo("908.7650")); } 

Très rarement, vous voudriez une chaîne vide si la valeur est 0.

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

La réponse la mieux notée est incorrecte et a perdu 10 minutes du temps (le plus) des gens.

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

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

 double whateverYouWantToChange = whateverYouWantToChange.ToSsortingng("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, je devais utiliser:

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

Une méthode de piratage, y compris la conversion en chaîne, est la suivante:

 public ssortingng FormatTo2Dp(decimal myNumber) { // Use schoolboy rounding, not bankers. myNumber = Math.Round(myNumber, 2, MidpointRounding.AwayFromZero); return ssortingng.Format("{0:0.00}", myNumber); }