¿Cómo puedo formatear un C# decimal para eliminar los siguientes 0's extra?

Question

Quiero formatear una cadena como un decimal, pero el decimal contiene algunos ceros siguientes después del decimal. ¿Cómo lo formateo de manera que desaparezcan esos 0 sin sentido?

string.Format("{0}", 1100M); 
string.Format("{0}", 1100.1M); 
string.Format("{0}", 1100.100M); 
string.Format("{0}", 1100.1000M); 

muestra:

1100 
1100.1 
1100.100 
1100.1000 

pero yo quiero que sea:

1100 
1100.1 
1100.1 
1100.1 

Como referencia, aquí hay otras cuestiones que son esencialmente duplicados de éste, que he encontrado gracias a las respuestas dadas aquí:

• Parse decimal and filter extra 0 on the right?
• Best way to display decimal without trailing zeroes
• How can I strip zeros and decimal points off of decimal strings?

Answer 1

Usted puede utilizar ToString() con el General ("G") Format Specifier para lograr el resultado deseado . Los ceros finales se truncan al usar esta cadena de formato con una precisión especificada. Para evitar el redondeo en cualquier situación, deberá establecer la precisión al máximo permitido para decimales (29).

La línea de código para producir lo que desea es number.ToString("G29"), donde number es su decimal original.

Tenga en cuenta que cualquier número menor que 0.0001 se convertirá a notación científica. Más detalles sobre cómo funciona este formateador se pueden encontrar en el enlace de referencia anterior.

Answer 2

Se puede especificar el format string así:

String.Format("{0:0.000}", x); 

Answer 3

String.Format("{0:0.##}", 123.0); // "123" 

Answer 4

No son necesariamente sin sentido - que indican la precisión durante el cálculo. Los decimales mantienen su nivel de precisión, en lugar de normalizarse.

Tengo un código en this answer que devolverá un valor normalizado; podría usarlo y formatear el resultado. Por ejemplo:

using System; 
using System.Numerics; 

class Test 
{ 
    static void Display(decimal d) 
    { 
     d = d.Normalize(); // Using extension method from other post 
     Console.WriteLine(d); 
    } 

    static void Main(string[] args) 
    { 
     Display(123.4567890000m); // Prints 123.456789 
     Display(123.100m);  // Prints 123.1 
     Display(123.000m);  // Prints 123 
     Display(123.4567891234m); // Prints 123.4567891234 
    } 
} 

I sospechoso que la mayoría de los enfoques de cadena de formato se producirá un error. Supongo que una cadena de formato de "0". y luego 28 # caracteres funcionarían, pero sería muy feo ...

Answer 5

Creo que quiere hacer:

var s = String.Format("{0:#####.###}"); 

Answer 6

Muy pocas respuestas ya. A menudo me refiero a esta hoja de trucos: http://blog.stevex.net/string-formatting-in-csharp/

Answer 7

Algo hacker, pero esto debería funcionar:

decimal a = 100.00M; 
string strNumber = string.Format("{0}", a); 
Console.WriteLine(strNumber.Contains('.') ? strNumber.TrimEnd('0').TrimEnd('.') : strNumber); 

Answer 8

¿Qué tal:

string FormatDecimal(decimal d) 
{ 
    const char point = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator[0]; 
    string s = d.ToString(); 
    // if there's no decimal point, there's nothing to trim 
    if (!s.Contains(point) == -1) 
     return s; 
    // trim any trailing 0s, followed by the decimal point if necessary 
    return s.TrimEnd('0').TrimEnd(point); 
} 

Answer 9

string s = d.ToString("0.#############################"); 

Answer 10

double a = 1100.00 
double b =1100.1 
double c = 1100.100 
double d =1100.1000 

Remove last zero after point 


string stra = a.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strb = b.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strc = c.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strd = d.toString("0.00").TrimEnd('0').TrimEnd('.'); 

Output 

1100 
1100.1 
1100.1 
1100.1 

Answer 11

A diferencia de lo que todo el mundo recomienda el uso de un especificador G formato que sugeriría lo siguiente para preservar tanto separador de miles y el punto decimal, mientras que la eliminación de ceros de la izquierda extra:

{0:#,#.##} 

El resultado de esta el formato es mucho mejor que G en la mayoría de los casos:

String.Format("{0:#,#.##}",25/2.4); 
10.42 

String.Format("{0:#,#.##}",1000000); 
1,000,000 

String.Format("{0:#,#.##}",1000000.3600000); 
1,000,000.36 

An d el especificador G realmente no puede manejar todas las combinaciones posibles:

String.Format("{0:G29}",25/2.4); 
10.416666666666668 

String.Format("{0:G2}",25/2.4); 
10 

String.Format("{0:G29}",1000000.3600000); 
1000000.36 

String.Format("{0:G2}",1000000.3600000); 
1E+06