Come si formatta un decimale C# per rimuovere gli extra seguenti 0?

Question

Desidero formattare una stringa come decimale, ma il decimale contiene alcuni zeri seguenti dopo il decimale. Come faccio a formattarlo in modo tale che quelli senza significato scompaiano?

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

display:

1100 
1100.1 
1100.100 
1100.1000 

ma io voglio che sia:

1100 
1100.1 
1100.1 
1100.1 

Per riferimento, qui ci sono altre questioni che sono essenzialmente i duplicati di questo, che ho trovato grazie alle risposte date qui:

• 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

È possibile utilizzare ToString() con il General ("G") Format Specifier per ottenere il risultato desiderato . Gli zeri finali vengono troncati quando si utilizza questa stringa di formato con una precisione specificata. Per evitare l'arrotondamento in qualsiasi situazione, è necessario impostare la precisione sul massimo consentito per i decimali (29).

La riga di codice per produrre ciò che si desidera è number.ToString("G29"), dove number è il proprio decimale originale.

Tenere presente che qualsiasi numero inferiore a 0,0001 verrà convertito in notazione scientifica. Maggiori dettagli su come funziona questo formattatore possono essere trovati al link di riferimento sopra.

Answer 2

È possibile specificare il format string in questo modo:

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

Answer 3

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

Answer 4

Non sono necessariamente priva di significato - indicano la precisione durante il calcolo. I decimali mantengono il loro livello di precisione, piuttosto che essere normalizzati.

Ho un codice in this answer che restituirà un valore normalizzato, è possibile utilizzarlo e quindi formattare il risultato. Per esempio:

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

ho sospetto che la maggior parte degli approcci format string falliranno. Direi che una stringa di formato di "0". e poi 28 # personaggi avrebbe funzionato, ma sarebbe molto brutto ...

Answer 5

Credo che si vuole fare:

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

Answer 6

Un bel paio di risposte già. Spesso mi riferisco a questo foglietto: http://blog.stevex.net/string-formatting-in-csharp/

Answer 7

Un po 'hacker, ma questo dovrebbe funzionare:

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

Answer 8

ne dite:

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 differenza di quello che tutti suggerisco di utilizzare un identificatore di formato G vorrei suggerire quanto segue per preservare sia separatore delle migliaia e punto decimale durante la rimozione zeri finali aggiuntivi:

{0:#,#.##} 

Il risultato di questo il formato è molto meglio di G nella maggior parte dei casi:

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

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

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

Un d lo specificatore G non è in grado di gestire tutte le combinazioni possibili:

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