Meilleure façon d'afficher les décimales sans les zéros de fin

Question

Existe-t-il un formateur d'affichage qui permette d'afficher les décimales sous la forme de ces chaînes de caractères en c# sans faire d'arrondi ?

// decimal -> string

20 -> 20
20.00 -> 20
20.5 -> 20.5
20.5000 -> 20.5
20.125 -> 20.125
20.12500 -> 20.125
0.000 -> 0

{0.#} sera arrondi, et l'utilisation d'une fonction de type Trim ne fonctionnera pas avec une colonne numérique liée dans une grille.

Answer 1

Avez-vous un nombre maximum de décimales à afficher ? (Vos exemples ont un maximum de 5).

Si c'est le cas, je pense que la mise en forme avec "0.#####" donnera les résultats escomptés.

    static void Main(string[] args)
    {
        var dList = new decimal[] { 20, 20.00m, 20.5m, 20.5000m, 20.125m, 20.12500m, 0.000m };

        foreach (var d in dList)
            Console.WriteLine(d.ToString("0.#####"));
    }

Answer 2

Je viens d'apprendre à utiliser correctement le G spécificateur de format. Voir le Documentation MSDN . Une note un peu plus bas indique que les zéros de fin seront conservés pour les types décimaux lorsqu'aucune précision n'est spécifiée. Je ne sais pas pourquoi ils font cela, mais le fait de spécifier le nombre maximum de chiffres pour notre précision devrait résoudre ce problème. Donc, pour le formatage des décimales, G29 est la meilleure solution.

decimal test = 20.5000m;
test.ToString("G"); // outputs 20.5000 like the documentation says it should
test.ToString("G29"); // outputs 20.5 which is exactly what we want

Answer 3

Ce format de chaîne devrait vous réjouir : "0.#############################". N'oubliez pas que les décimales peuvent avoir au maximum 29 chiffres significatifs.

Exemples :

? (1000000.00000000000050000000000m).ToString("0.#############################")
-> 1000000.0000000000005

? (1000000.00000000000050000000001m).ToString("0.#############################")
-> 1000000.0000000000005

? (1000000.0000000000005000000001m).ToString("0.#############################")
-> 1000000.0000000000005000000001

? (9223372036854775807.0000000001m).ToString("0.#############################")
-> 9223372036854775807

? (9223372036854775807.000000001m).ToString("0.#############################")
-> 9223372036854775807.000000001

Answer 4

Il s'agit d'une autre variante de ce que j'ai vu plus haut. Dans mon cas, je dois conserver tous les chiffres significatifs à droite de la virgule, c'est-à-dire supprimer tous les zéros après le chiffre le plus significatif. J'ai juste pensé qu'il serait bon de le partager. Je ne peux pas me porter garant de l'efficacité de cette méthode, mais lorsque l'on essaie d'atteindre l'esthétique, on est déjà condamné à l'inefficacité.

public static string ToTrimmedString(this decimal target)
{
    string strValue = target.ToString(); //Get the stock string

    //If there is a decimal point present
    if (strValue.Contains("."))
    {
        //Remove all trailing zeros
        strValue = strValue.TrimEnd('0');

        //If all we are left with is a decimal point
        if (strValue.EndsWith(".")) //then remove it
            strValue = strValue.TrimEnd('.');
    }

    return strValue;
}

C'est tout, je voulais juste donner mon avis.

Answer 5

Méthode d'extension :

public static class Extensions
{
    public static string TrimDouble(this string temp)
    {
        var value = temp.IndexOf('.') == -1 ? temp : temp.TrimEnd('.', '0');
        return value == string.Empty ? "0" : value;
    }
}

Exemple de code :

double[] dvalues = {20, 20.00, 20.5, 20.5000, 20.125, 20.125000, 0.000};
foreach (var value in dvalues)
    Console.WriteLine(string.Format("{0} --> {1}", value, value.ToString().TrimDouble()));

Console.WriteLine("==================");

string[] svalues = {"20", "20.00", "20.5", "20.5000", "20.125", "20.125000", "0.000"};
foreach (var value in svalues)
    Console.WriteLine(string.Format("{0} --> {1}", value, value.TrimDouble()));

Sortie :

20 --> 20
20 --> 20
20,5 --> 20,5
20,5 --> 20,5
20,125 --> 20,125
20,125 --> 20,125
0 --> 0
==================
20 --> 20
20.00 --> 2
20.5 --> 20.5
20.5000 --> 20.5
20.125 --> 20.125
20.125000 --> 20.125
0.000 --> 0