web-dev-qa-db-fra.com

Problème de conversion décimale ToString () en C #

Je rencontre un problème lorsque je tente de convertir decimal? en string. Le scénario est

decimal decimalValue = .1211;
string value = (decimalValue * 100).ToString();

Résultat actuel: valeur = 12.1100

Résultat attendu: valeur = 12.11

S'il vous plaît laissez-moi savoir, ce qui pourrait être une raison pour cela.

c#stringdecimal
16
Pushkar

Decimal conserve les zéros à la fin d'un nombre Decimal. Si vous voulez deux décimales à la place:

decimal? decimalValue = .1211m;
string value = ((decimal)(decimalValue * 100)).ToString("#.##")

http://msdn.Microsoft.com/en-us/library/0c899ak8.aspx

ou

string value = ((decimal)(decimalValue * 100)).ToString("N2")

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

De System.Decimal :

Un nombre décimal est une virgule flottante valeur qui consiste en un signe, un valeur numérique où chaque chiffre dans le la valeur est comprise entre 0 et 9 et un facteur d'échelle qui indique la position d'un point décimal flottant qui sépare les parties intégrale et de la valeur numérique.

La représentation binaire d'un nombre décimal la valeur consiste en un signe de 1 bit, un Nombre entier 96 bits et une mise à l'échelle facteur utilisé pour diviser le 96 bits entier et spécifier quelle partie de celui-ci est une fraction décimale. La mise à l'échelle facteur est implicitement le nombre 10, élevé à un exposant allant de 0 à 28. Par conséquent, le binaire la représentation d'une valeur décimale est de la forme, ((-296 à 296)/dix(0 à 28)), où -296-1 est égal à MinValue et 296-1 est égal à Valeur max.

Le facteur de mise à l'échelle conserve également les Zéros à la fin d'un nombre décimal . Les zéros à la fin n'affectent pas la valeur D'un nombre décimal dans Opérations arithmétiques ou de comparaison . Toutefois, >> les zéros de fin peuvent être Révélés par la méthode ToString si une chaîne de format appropriée .__ est appliquée <<.

Remarques:

  1. la multiplication décimale doit être convertie en décimal, car Nullable<decimal>.ToString n'a pas de fournisseur de format

  2. comme Chris l'a souligné, vous devez gérer le cas où le Nullable<decimal> est null. Une façon consiste à utiliser le Null-Coalescing-Operator:

    ((decimal)(decimalValue ?? 0 * 100)).ToString("N2")

Cet article de Jon Skeet mérite d'être lu: 

Virgule flottante décimale dans .NET (recherche pour en gardant les zéros si vous êtes impatient)

19
Rango

Puisque vous utilisez Nullable<T> en tant que decimal, Nullable<T>.ToString() méthode ne nécessite pas de surcharge, prend des paramètres que vous pouvez utiliser pour le formatage.

Au lieu de, vous pouvez explicitement le convertir en decimal et vous pouvez utiliser la méthode .ToString() pour le formatage.

Utilisez simplement le format "0.00" dans votre méthode .ToString().

decimal? decimalValue = .1211M;
string value = ((decimal)(decimalValue * 100)).ToString("0.00");
Console.WriteLine(value);

La sortie sera;

12.11

Voici une DEMO .

Alternativement, vous pouvez utiliser Nullable<T>.Value sans conversation comme;

string value = (decimalValue * 100).Value.ToString("0.00");

Départ pour plus d'informations à partir de Custom Numeric Format Strings

6
Soner Gönül

Sinon, vous pouvez spécifier le format "F2", comme suit: string val = decVal.ToString("F2") car ceci spécifie 2 décimales.

2
Davio

Utilisez le spécificateur de format fixed-point ("F) .

   string value = (decimalValue * 100).ToString("F");

Le spécificateur de précision par défaut est basé sur la valeur NumberFormatInfo.NumberDecimalDigits, propriété par défaut de 2. Si vous ne spécifiez pas un chiffre après "F", il spécifie par défaut deux chiffres décimaux.

F0 - No decimal places
F1 - One decimal place
2
Mudassir Hasan

Si vous ne voulez pas limiter à un certain nombre de chiffres décimaux:

decimal? decimalValue = .1211;
string value = decimalValue == null 
               ? "0"
               : decimalValue == 0
               ? "0"
               : (decimalValue * 100).ToString().TrimEnd('0');

Cela supprimera les zéros de fin de chaîne (le cas échéant) et retournera "0" si decimalValue est null Si la valeur est 0, "0" est renvoyé sans ajustement.

1
John Willemse
String.Format("{0:0.00}", decimalValue * 100);

Vous pouvez utiliser .Format() comme alternative à .ToString("0.00").

0
emre nevayeshirazi

Puisque decimal? n'a pas de surcharge ToString(string format), le moyen le plus simple consiste à utiliser String.Format à la place, ce qui fournira des résultats cohérents avec le cas null pour decimalValue également (ce qui donnera une chaîne vide) par rapport au code d'origine:

string value = String.Format("{0:#.##}", decimalValue * 100);

Mais il y a d'autres considérations pour d'autres chiffres sur lesquelles vous n'étiez pas clairs.

Si vous avez un nombre qui ne produit pas une valeur supérieure à 0, affiche-t-il un zéro non significatif? C'est-à-dire que, pour 0.001211, est-il affiché comme 0.12 ou .12? Si vous voulez le zéro non significatif, utilisez ceci à la place (notez le changement de #.## à 0.##):

string value = String.Format("{0:0.##}", decimalValue * 100);

Si vous avez plus de 2 décimales significatives, voulez-vous qu'elles soient affichées? Donc, si vous aviez .12113405, cela afficherait-il 12.113405? Si oui, utilisez:

string value = String.Format("{0:#.############}", decimalValue * 100);

(Honnêtement, je pense qu'il doit y avoir une chaîne meilleure de formatage que cela, d'autant plus qu'elle ne prend en charge que 12 décimales)

Et bien sûr, si vous voulez les deux zéros de tête et plusieurs décimales, combinez simplement les deux ci-dessus:

string value = String.Format("{0:0.############}", decimalValue * 100);
0
Chris Sinclair