Meilleur moyen d'afficher les décimales sans zéros de fin

Existe-t-il un formateur d'affichage qui produira des décimales comme ces représentations de chaîne en c # sans faire aucun 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. #} arrondira et l'utilisation d'une fonction de type Trim ne fonctionnera pas avec une colonne numérique liée dans une grille.

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

Si tel est le cas, je pense 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.#####"));
    }

Je viens d'apprendre à utiliser correctement le Gspécificateur de format. Consultez la documentation MSDN . Il y a une note un peu plus bas qui indique que les zéros de fin seront conservés pour les types décimaux lorsqu'aucune précision n'est spécifiée. Pourquoi ils feraient cela, je ne sais pas, mais spécifier le nombre maximum de chiffres pour notre précision devrait résoudre ce problème. Donc, pour le formatage des décimales, G29c'est le meilleur pari.

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

Ce format de chaîne devrait rendre votre journée: "0. ###########################". Gardez à l'esprit que les décimales 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

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 de la virgule décimale, ce qui signifie supprimer tous les zéros après le chiffre le plus significatif. Je pensais juste que ce serait bien de partager. Je ne peux pas garantir l'efficacité de cela, mais lorsque vous essayez d'atteindre l'esthétique, vous êtes déjà 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 cents.

Autre solution, basée sur la réponse de 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);
}

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()));

Production:

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

Je ne pense pas que ce soit possible 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', '.');
}

C'est assez facile à faire hors 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 décimal.

La seule chose que vous devez faire est d'ajouter .ToString().TrimEnd('0','.');à une variable décimale pour convertir a Decimalen a Stringsans zéros de fin, comme dans l'exemple ci-dessus.

Dans certaines régions, cela devrait être un .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 être sûr).

(vous pouvez également ajouter les deux comme paramètres)

decimal val = 0.000000000100m;
string result = val == 0 ? "0" : val.ToString().TrimEnd('0').TrimEnd('.');

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;
    }

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 maximum de chiffres significatifs après le point à afficher au moment de l'exécution;

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

vous pouvez contrôler explicitement une culture.

Vous pouvez créer une méthode d'extension

public static class ExtensionMethod {
  public static decimal simplify_decimal(this decimal value) => decimal.Parse($"{this:0.############}");
}

J'ai créé les méthodes d'extension ci-dessous pour moi-même pour s'adapter à l'un de mes projets, mais elles seront peut-être bénéfiques à quelqu'un d'autre.

using System.Numerics;
using System.Text.RegularExpressions;
internal static class ExtensionMethod
{
    internal static string TrimDecimal(this BigInteger obj) => obj.ToString().TrimDecimal();
    internal static string TrimDecimal(this decimal obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this double obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this float obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this string obj)
    {
        if (string.IsNullOrWhiteSpace(obj) || !Regex.IsMatch(obj, @"^(\d+([.]\d*)?|[.]\d*)$")) return string.Empty;
        Regex regex = new Regex("^[0]*(?<pre>([0-9]+)?)(?<post>([.][0-9]*)?)$");
        MatchEvaluator matchEvaluator = m => string.Concat(m.Groups["pre"].Length > 0 ? m.Groups["pre"].Value : "0", m.Groups["post"].Value.TrimEnd(new[] { '.', '0' }));
        return regex.Replace(obj, matchEvaluator);
    }
}

Bien qu'il faudra une référence à System.Numerics.