Formatage d'un flottant à 2 décimales

210

Je construis actuellement un module de vente pour un site Web de clients. Jusqu'à présent, j'ai le prix de vente à calculer parfaitement, mais là où je suis coincé, c'est le formatage de la sortie à 2 décimales.

J'appelle actuellement cela dans une variable afin que je puisse lier les résultats aux résultats à une liste.

Sale = float.Parse(((x.Sale_Price - (x.Sale_Price * (x.Discount_Price / 100))).ToString())),

Quelqu'un peut-il me montrer comment formater la sortie à 2 décimales ?? Merci beaucoup!

Callum
la source
Vérifiez cela, je ne suis pas sûr, mais cela pourrait fonctionner ToString ("#. ##");
Syeda

Réponses:

467

Vous pouvez transmettre le format à la ToStringméthode, par exemple:

myFloatVariable.ToString("0.00"); //2dp Number

myFloatVariable.ToString("n2"); // 2dp Number

myFloatVariable.ToString("c2"); // 2dp currency

Chaînes de format de nombre standard

WraithNath
la source
38
"N2" et "C2" ajouteront mille séparateurs tandis que "0,00" ne le fera pas.
Marc K
5
Juste au cas où vous n'êtes pas sûr (je l'étais), toutes ces façons de formater une valeur flottante fournissent des arrondis.
RenniePet
46

La première chose que vous devez faire est d'utiliser le decimaltype au lieu des floatprix. L'utilisation floatest absolument inacceptable pour cela car elle ne peut pas représenter avec précision la plupart des fractions décimales.

Une fois que vous avez fait cela, vous Decimal.Round()pouvez utiliser pour arrondir à 2 endroits.

Michael Borgwardt
la source
36

String.Format("{0:#,###.##}", value)

Un exemple plus complexe de formatage de chaînes en C # :

String.Format("{0:$#,##0.00;($#,##0.00);Zero}", value);

Cela produira "$ 1,240.00" si passé 1243.50. Il affichera le même format mais entre parenthèses si le nombre est négatif et affichera la chaîne «Zero» si le nombre est zéro.

alexandrul
la source
4
string outString= number.ToString("####0.00");
danyolgiax
la source
1
Il existe des différences entre "0" et "#" dans un format personnalisé. "0": remplace le zéro par le chiffre correspondant s'il y en a un; sinon, zéro apparaît dans la chaîne de résultat. "#": Remplace le symbole "#" par le chiffre correspondant s'il y en a un; sinon, aucun chiffre n'apparaît dans la chaîne de résultat. Référence
劉鎮 瑲
3

Comme déjà mentionné, vous devrez utiliser un résultat formaté; qui est fait par les Write(), WriteLine(), Format()et ToString()méthodes.

Ce qui n'a pas été mentionné est le format à virgule fixe qui permet un nombre spécifié de décimales. Il utilise un «F» et le nombre suivant le «F» est le nombre de décimales produites, comme indiqué dans les exemples.

Console.WriteLine("{0:F2}", 12);    // 12.00 - two decimal places
Console.WriteLine("{0:F0}", 12.3);  // 12 - ommiting fractions
Jackson
la source
2

C'est pour les cas où vous souhaitez utiliser des chaînes interpolées . En fait, je poste cela parce que je suis fatigué des essais et des erreurs et que je fais défiler des tonnes de documents à chaque fois que je dois formater du scalaire.

$"{1234.5678:0.00}"        "1234.57"        2 decimal places, notice that value is rounded
$"{1234.5678,10:0.00}"     "   1234.57"     right-aligned
$"{1234.5678,-10:0.00}"    "1234.57   "     left-aligned
$"{1234.5678:0.#####}"     "1234.5678"      5 optional digits after the decimal point
$"{1234.5678:0.00000}"     "1234.56780"     5 forced digits AFTER the decimal point, notice the trailing zero
$"{1234.5678:00000.00}"    "01234.57"       5 forced digits BEFORE the decimal point, notice the leading zero
$"{1234.5612:0}"           "1235"           as integer, notice that value is rounded
$"{1234.5678:F2}"          "1234.57"        standard fixed-point
$"{1234.5678:F5}"          "1234.56780"     5 digits after the decimal point, notice the trailing zero
$"{1234.5678:g2}"          "1.2e+03"        standard general with 2 meaningful digits, notice "e"
$"{1234.5678:G2}"          "1.2E+03"        standard general with 2 meaningful digits, notice "E"
$"{1234.5678:G3}"          "1.23E+03"       standard general with 3 meaningful digits
$"{1234.5678:G5}"          "1234.6"         standard general with 5 meaningful digits
$"{1234.5678:e2}"          "1.23e+003"      standard exponential with 2 digits after the decimal point, notice "e"
$"{1234.5678:E3}"          "1.235E+003"     standard exponential with 3 digits after the decimal point, notice "E"
$"{1234.5678:N2}"          "1,234.57"       standard numeric, notice the comma
$"{1234.5678:C2}"          "$1,234.57"      standard currency, notice the dollar sign
$"{1234.5678:P2}"          "123,456.78 %"   standard percent, notice that value is multiplied by 100
$"{1234.5678:2}"           "2"              :)

Avertissement de performances

Les chaînes interpolées sont lentes. D'après mon expérience, c'est l'ordre (rapide à lent):

  1. value.ToString(format)+" blah blah"
  2. string.Format("{0:format} blah blah", value)
  3. $"{value:format} blah blah"
saastn
la source