Melhor maneira de exibir decimal sem zeros à direita

Existe um formatador de exibição que produzirá decimais como essas representações de string em c # sem fazer nenhum arredondamento?

// 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. #} irá arredondar e usar alguma função do tipo Trim não funcionará com uma coluna numérica ligada em uma grade.

Você tem um número máximo de casas decimais que precisa exibir? (Seus exemplos têm no máximo 5).

Nesse caso, acho que a formatação com "0. #####" faria o que você deseja.

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

Acabei de aprender como usar corretamente o Gespecificador de formato. Consulte a documentação do MSDN . Há uma nota um pouco abaixo que afirma que os zeros finais serão preservados para tipos decimais quando nenhuma precisão for especificada. Por que eles fariam isso, eu não sei, mas especificar o número máximo de dígitos para nossa precisão deve resolver o problema. Portanto, para formatar decimais, G29é a melhor aposta.

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

Este formato de string deve tornar o seu dia: "0. ##################################". Lembre-se de que os decimais podem ter no máximo 29 dígitos significativos.

Exemplos:

? (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

Esta é mais uma variação do que vi acima. No meu caso, preciso preservar todos os dígitos significativos à direita da vírgula decimal, o que significa eliminar todos os zeros após o dígito mais significativo. Achei que seria bom compartilhar. Eu não posso garantir a eficiência disso, mas quando você tenta atingir a estética, você já está condenado às ineficiências.

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

Isso é tudo, só queria jogar meus dois centavos.

Outra solução, baseada na resposta do dislexicanaboko , mas independente da cultura atual:

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étodo de extensão:

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

Código de exemplo:

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

Resultado:

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

Não acho que seja possível out-of-the-box, mas um método simples como este deve servir

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

    return result.TrimEnd('0', '.');
}

É muito fácil de fazer fora da caixa:

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

isso removerá todos os zeros finais de seu decimal.

A única coisa que você precisa fazer é adicionar .ToString().TrimEnd('0','.');a uma variável decimal para converter a Decimalem a Stringsem zeros à direita, como no exemplo acima.

Em algumas regiões, deve ser um .ToString().TrimEnd('0',','); (onde eles usam uma vírgula em vez de um ponto, mas você também pode adicionar um ponto e uma vírgula como parâmetros para ter certeza).

(você também pode adicionar ambos como parâmetros)

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

Acabei com o seguinte código:

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

Acabei com esta 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);
    }

Vantagens:

você pode especificar o número máximo de dígitos significativos após o ponto a ser exibido no tempo de execução;

você pode especificar explicitamente um método round;

você pode controlar explicitamente uma cultura.

Você pode criar um método de extensão

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

Eu fiz os métodos de extensão abaixo para mim mesmo para caber em um dos meus projetos, mas talvez eles sejam benéficos para outra pessoa.

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

Embora exija uma referência a System.Numerics.