web-dev-qa-db-fra.com

Meilleure façon d'afficher des décimales sans zéros

Existe-t-il un formateur d’affichage capable de générer des décimales sous la forme de représentations de chaîne en c # sans arrondir?

// 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 Limiter ne fonctionnera pas avec une colonne numérique liée dans une grille.

c#formattingdecimal
94
JC.

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

Si tel est le cas, je penserais que le formatage avec "0. #####" ferait ce que vous voulez.

    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.#####"));
    }
135
Toby

Je viens d'apprendre à utiliser correctement le spécificateur de format G. Voir le documentation MSDN . Il y a une note un peu plus bas qui indique que les zéros de fin seront préservés pour les types décimaux quand aucune précision n'est spécifiée. Pourquoi ne feraient-ils pas cela, je l'ignore, mais le fait de spécifier le nombre maximal de chiffres pour notre précision devrait résoudre ce problème. Donc, pour la mise en forme des nombres décimaux, G29 est le meilleur choix.

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
30
Schmalls

Ce format de chaîne devrait faire de votre journée: "0. ##############################". Gardez à l'esprit que les nombres décimaux peuvent avoir au plus 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
15
Erwin Mayer

C'est encore une autre variation de ce que j'ai vu ci-dessus. Dans mon cas, je dois conserver tous les chiffres significatifs à droite du point décimal, ce qui signifie supprimer tous les zéros après le chiffre le plus significatif. Je pensais que ce serait bien de partager. Je ne peux cependant pas en garantir l'efficacité, mais lorsque vous essayez d'obtenir une esthétique, vous êtes déjà pratiquement condamné à des inefficacités.

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 ajouter mes deux sous.

9
dyslexicanaboko

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
4
jgauffin

Une autre solution, basée sur la réponse dyslexicanaboko , mais indépendante de la culture actuelle:

public static string ToTrimmedString(this decimal num)
{
    string str = num.ToString();
    string decimalSeparator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
    if (str.Contains(decimalSeparator))
    {
        str = str.TrimEnd('0');
        if(str.EndsWith(decimalSeparator))
        {
            str = str.RemoveFromEnd(1);
        }
    }
    return str;
}

public static string RemoveFromEnd(this string str, int characterCount)
{
    return str.Remove(str.Length - characterCount, characterCount);
}
3
David Dostal

C'est assez facile à faire en dehors de la boîte:

Decimal YourValue; //just as example   
String YourString = YourValue.ToString().TrimEnd('0','.');

cela supprimera tous les zéros de fin de votre nombre décimal.

La seule chose à faire est d’ajouter .ToString().TrimEnd('0','.'); à une variable décimale pour convertir un Decimal en un String sans zéros, comme dans l’exemple ci-dessus.

Dans certaines régions, il devrait s'agir d'une .ToString().TrimEnd('0',','); (où ils utilisent une virgule au lieu d'un point, mais vous pouvez également ajouter un point et une virgule comme paramètres pour en être sûr).

(vous pouvez également ajouter les deux en tant que paramètres)

2
Mervin

Je ne pense pas que ce soit prêt à l'emploi, mais une méthode simple comme celle-ci devrait le faire

public static string TrimDecimal(decimal value)
{
    string result = value.ToString(System.Globalization.CultureInfo.InvariantCulture);
    if (result.IndexOf('.') == -1)
        return result;

    return result.TrimEnd('0', '.');
}
1
Tim Skauge
decimal val = 0.000000000100m;
string result = val == 0 ? "0" : val.ToString().TrimEnd('0').TrimEnd('.');
0
Jerry Liang

J'ai fini avec cette variante:

public static string Decimal2StringCompact(decimal value, int maxDigits)
    {
        if (maxDigits < 0) maxDigits = 0;
        else if (maxDigits > 28) maxDigits = 28;
        return Math.Round(value, maxDigits, MidpointRounding.ToEven).ToString("0.############################", CultureInfo.InvariantCulture);
    }

Avantages:

vous pouvez spécifier le nombre maximal de chiffres significatifs après le point à afficher au moment de l'exécution;

vous pouvez spécifier explicitement une méthode de ronde;

vous pouvez contrôler explicitement une culture.

0
lilo0

J'ai fini avec le code suivant:

    public static string DropTrailingZeros(string test)
    {
        if (test.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
        {
            test = test.TrimEnd('0');
        }

        if (test.EndsWith(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
        {
            test = test.Substring(0,
                test.Length - CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator.Length);
        }

        return test;
    }
0
Arsen Zahray