La mejor manera de mostrar decimal sin ceros finales

Acabo de aprender a usar correctamente el especificador de formato G. Vea la Documentación de MSDN . Hay una nota un poco más abajo que indica que los ceros finales se conservarán para los tipos decimales cuando no se especifique precisión. No sé por qué harían esto, pero especificar el número máximo de dígitos para nuestra precisión debería solucionar ese problema. Así que para formatear decimales, G29 es la mejor apuesta.

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 cadena debería hacer su día: "0.#############################". Sin embargo, tenga en cuenta que los decimales pueden tener como máximo 29 dígitos significativos.

Ejemplos:

? (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 es otra variación de lo que vi arriba. En mi caso necesito conservar todos los dígitos significativos a la derecha del punto decimal, lo que significa soltar todos los ceros después del dígito más significativo. Sólo pensé que sería bueno compartir. Sin embargo, no puedo responder por la eficiencia de esto, pero cuando intentas lograr la estética, ya estás casi condenado a ineficiencias.

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

Eso es todo, solo quería aportar mis dos centavos.

Método de extensión:

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 ejemplo:

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

Salida:

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

Otra solución, basada en la respuesta de dyslexicanaboko, pero independiente de la cultura actual:

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

Es bastante fácil de hacer fuera de la caja:

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

Eso eliminará todos los ceros finales de su Decimal.

Lo único que necesita hacer es agregar .ToString().TrimEnd('0','.'); a una variable decimal para convertir un Decimal en una cadena sin ceros finales, como en el ejemplo anterior.

En algunas regiones debe ser un .ToString().TrimEnd('0',','); (donde se usa una coma en lugar de un punto, pero también se puede agregar un punto y una coma como parámetros para estar seguro)

(también puede agregar ambos como parámetros)

No creo que sea posible fuera de la caja, pero un método simple como este debería hacerlo

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

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

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

Terminé con el siguiente 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;
    }