Comment dois-je formater un C# décimal pour supprimer les suivantes 0?

Je veux formater une chaîne de caractères comme une virgule, mais la virgule contient certains suite de zéros après la virgule. Comment puis-je formater tels que ceux de sens 0 disparaître?

string.Format("{0}", 1100M);
string.Format("{0}", 1100.1M);
string.Format("{0}", 1100.100M);
string.Format("{0}", 1100.1000M);

affiche:

1100
1100.1
1100.100
1100.1000

mais je veux qu'il soit:

1100
1100.1
1100.1
1100.1

Pour référence, voici d'autres questions qui sont essentiellement des doublons de ce que j'ai trouvé grâce aux réponses données ici:

  • Est 1002.231 Juste un exemple? Qui est, voulez-vous 1.12000 à 1.12 ou 1.120?
  • Notez que si vous voulez une valeur décimale, vous devez utiliser l'un, par exemple, 1100.1000 m. Remarque: le "m" pour "décimal littérale".
  • Merci, j'ai remarqué que aussi et est allé à la fixer, et votre commentaire est en attente pour moi, quand je suis retourné.. Si vite... 😉
  • Juste un exemple, oui, j'ai mis à jour avec plus d'exemples.
InformationsquelleAutor Scott Stafford | 2011-01-24
  1. 80

    Vous pouvez utiliser ToString() avec le Général ("G") Spécificateur de Format pour obtenir le résultat souhaité. Les zéros à droite sont tronqués lors de l'utilisation de ce format de chaîne de caractères avec une précision spécifiée. Afin d'éviter l'arrondissement dans toutes les situations, vous aurez besoin de définir la précision de la valeur maximale autorisée pour les décimales (29).

    La ligne de code à produire ce que vous voulez, c'est number.ToString("G29"), où number est votre origine décimal.

    Être conscient que tous les nombres plus petits que 0,0001 seront convertis à la notation scientifique. Plus de détails sur la façon dont ce formateur œuvres peuvent être trouvés dans la référence ci-dessus.

    • Je pense que c'est la meilleure solution à la question.
    • D'accord -- commutation de réponse. Merci, @Herohtar.
    • AVERTISSEMENT: méfiez-vous des valeurs comme 0.000001. G29 format de présenter le plus rapidement possible si cela va changer à la notation exponentielle. chaîne de caractères.Format("{0:G29}", décimal.Parse("0.00000001",Système.De la mondialisation.CultureInfo.GetCultureInfo("fr-fr"))) donnera "1E-08" comme résultat. Le crédit va à Konrad ici: stackoverflow.com/questions/4525854/remove-trailing-zeros/...
    • Il semble qu'il passe en notation scientifique des nombres moins de 0,0001 (par exemple, 0.0001 reste le même, mais 0.00009 sera 9E-05) Qui semble peu probable d'être un problème dans la plupart des cas, de vouloir tronquer des zéros, mais une bonne chose à savoir tout de même.
    • Je ne dirais pas que c'est "peu probable" à tous. En fait, il est très probable que si quelqu'un travaille avec les décimales de moins de 1. Par exemple, j'magasin décimal(12,10) dans ma base de données, et G29 échouait sur 0.0000010000 ou quelque chose comme ça.
    • Le lien ne pointe pas vers le bon endroit plus...
    • La réponse a été mis à jour avec un lien correct et à jour.
    • Je reçois toujours les zéros de fin avec le "G" de mise en forme.
    • Le G29 n'est pas nécessaire. "G0"=="G29" pour les décimales
    • Que faire si je ne veux pas qu'il à utiliser la notation scientifique?

    InformationsquelleAutor Herohtar
  2. 21
    string s = d.ToString("0.#############################");
    InformationsquelleAutor Jason dinAlt
  3. 4

    Ils ne sont pas nécessairement dénuée de sens, ils indiquent la précision lors du calcul. Décimales de maintenir leur niveau de précision, plutôt que d'être normalisé.

    J'ai un peu de code dans cette réponse qui renvoie une valeur normalisée - vous pourriez l'utiliser, et puis le format du résultat. Par exemple:

    using System;
using System.Numerics;

class Test
{
    static void Display(decimal d)
    {
        d = d.Normalize(); //Using extension method from other post
        Console.WriteLine(d);
    }

    static void Main(string[] args)
    {
        Display(123.4567890000m); //Prints 123.456789
        Display(123.100m);        //Prints 123.1
        Display(123.000m);        //Prints 123
        Display(123.4567891234m); //Prints 123.4567891234
    }
}

    Je suspect que la plupart de la chaîne de format approches échouent. Je suppose qu'une chaîne de format de "0". et puis 28 # caractères de travail, mais il serait très laid...

    • Il ressemble à votre solution est pour .Net 4.0.
    • Sauf si vous utilisez un 3ème partie BigInteger mise en œuvre, oui. C'est aussi assez inefficace. D'autre part, il a l'avantage de travailler 🙂
    InformationsquelleAutor Jon Skeet
  4. 3

    Vous pouvez spécifier le chaîne de format comme ceci:

    String.Format("{0:0.000}", x);
    • Mais je ne sais pas qui il a trois décimales sur la fin, je voulais dire que comme un exemple. Je vais faire de la question plus claire.
    InformationsquelleAutor driis
  5. 3

    Comment sur:

    string FormatDecimal(decimal d)
{
    const char point = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator[0];
    string s = d.ToString();
    //if there's no decimal point, there's nothing to trim
    if (!s.Contains(point) == -1)
        return s;
    //trim any trailing 0s, followed by the decimal point if necessary
    return s.TrimEnd('0').TrimEnd(point);
}
    • L'Utilisation Du Système.De la mondialisation.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator au lieu de '.'?
    InformationsquelleAutor Gabe
  6. 3

    Contrairement à ce que tout le monde vous suggérons d'utiliser un G spécificateur de format je dirais que la suite de préserver à la fois le séparateur de milliers et le point décimal lors de la suppression supplémentaire de zéros à droite:

    {0:#,#.##}

    Le résultat de ce format est beaucoup mieux que de G dans la plupart des cas:

    String.Format("{0:#,#.##}",25/2.4);
10.42

String.Format("{0:#,#.##}",1000000);
1,000,000

String.Format("{0:#,#.##}",1000000.3600000);
1,000,000.36

    Et la G spécificateur ne peut pas vraiment gérer toutes les combinaisons possibles:

    String.Format("{0:G29}",25/2.4);
10.416666666666668

String.Format("{0:G2}",25/2.4);
10

String.Format("{0:G29}",1000000.3600000);
1000000.36

String.Format("{0:G2}",1000000.3600000);
1E+06
    InformationsquelleAutor Mohsen Afshin
  7. 2

    Assez peu de réponses déjà. Je fais souvent référence à cette feuille de triche: http://blog.stevex.net/string-formatting-in-csharp/

    InformationsquelleAutor Baz Hughes
  8. 2

    Un peu hackish, mais cela devrait fonctionner:

    decimal a = 100.00M;
string strNumber = string.Format("{0}", a);
Console.WriteLine(strNumber.Contains('.') ? strNumber.TrimEnd('0').TrimEnd('.') : strNumber);
    • Ack! Que faire si a = 100.000? Ou a = 0?
    • Que faire si a = 100M?
    • A été dans le processus de fixation
    • devrait être corrigé maintenant. Laissez-moi savoir si vous trouvez des contre-exemples à la mise à jour de réponse.
    • Ne serait pas l'esprit d'un downvote enlèvement, à moins que la mise à jour de la réponse n'est toujours pas satisfaisante?
    • retiré downvote selon votre correction. 🙂
    • merci 🙂

    InformationsquelleAutor Davy8
  9. 1

    Je crois que vous voulez faire:

    var s = String.Format("{0:#####.###}");
    • Échoue pour 123.45678900 m.
    InformationsquelleAutor AlG
  10. 1
    String.Format("{0:0.##}", 123.0); //"123"
    • Échoue pour 123.456789 m.
    • Doit être... de la Chaîne.Format("{0:0.0##}", 123.456789 m) Merci
    InformationsquelleAutor John K.
  11. -2
    double a = 1100.00
double  b =1100.1
double  c = 1100.100
double  d =1100.1000

Remove last zero after point


string stra = a.toString("0.00").TrimEnd('0').TrimEnd('.');
string strb = b.toString("0.00").TrimEnd('0').TrimEnd('.');
string strc = c.toString("0.00").TrimEnd('0').TrimEnd('.');
string strd = d.toString("0.00").TrimEnd('0').TrimEnd('.');

Output

1100
1100.1
1100.1
1100.1
    InformationsquelleAutor Rakesh Solanki