Formatage d'un flottant à 2 décimales

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!

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

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.

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.

Je crois:

String.Format("{0:0.00}",Sale);

Devrait le faire.

Voir Exemples de format de chaîne de lien C #

string outString= number.ToString("####0.00");

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

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"