How do I format a C# decimal to remove extra following 0's?

Question

I want to format a string as a decimal, but the decimal contains some following zeros after the decimal. How do I format it such that those meaningless 0's disappear?

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

displays:

but I want it to be:

For reference, here are other questions that are essentially duplicates of this, that I've found thanks to answers given here:

Is 1002.231 Just an example? That is, would you like 1.12000 to be 1.12 or 1.120? — n8wrl, Jan 24 '11 at 20:23
Note that if you want a *decimal* value, you should use one, e.g. 1100.1000m. Note the "m" for "decimal literal". — Jon Skeet, Jan 24 '11 at 20:26
@Jon: Thanks I noticed that also and went to fix it, and your comment was waiting for me when I returned.. So fast... ;) — Scott Stafford, Jan 24 '11 at 20:27

Herohtar · Accepted Answer · 2014-04-07T20:07:04.390

85

You can use ToString() with the General ("G") Format Specifier to achieve the desired result. Trailing zeros are truncated when using this format string with a precision specified. In order to prevent rounding in any situations, you will need to set the precision to the maximum allowed for decimals (29).

The line of code to produce what you want is number.ToString("G29"), where number is your original decimal.

Be aware that any numbers smaller than 0.0001 will be converted to scientific notation. More details on how this formatter works can be found at the reference link above.

edited Apr 07 '14 at 20:07

answered Jan 24 '11 at 21:20

Herohtar

5,347
4
31
41

5

I think this is the best solution to the question. – Wegged May 13 '11 at 17:17
2

Concur -- switched answer. Thanks, @Herohtar. – Scott Stafford Oct 05 '12 at 18:45
2

WARNING: Watch out for values like 0.000001. G29 format will present them in the shortest possible way so it will switch to the exponential notation. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-U‌S"))) will give "1E-08" as the result. Credit goes to Konrad here: http://stackoverflow.com/questions/4525854/remove-trailing-zeros/4525983#4525983 – Doug S Nov 07 '12 at 22:26
@DougS: It seems that it switches to scientific notation for numbers less than 0.0001 (eg, 0.0001 remains the same, but 0.00009 will be 9E-05) That seems unlikely to be a problem in most cases of wanting to truncate zeros, but a good thing to know nonetheless. – Herohtar Nov 09 '12 at 15:39
@Herohtar: I wouldn't say it's "unlikely" at all. In fact, it's very likely if someone is working with decimals less than 1. For instance, I store decimal(12,10) in my database, and G29 would fail on 0.0000010000 or anything like it. – Doug S Nov 10 '12 at 17:19
The answer has been updated with a correct link and current information. – Herohtar Apr 07 '14 at 20:08
I still get the trailing zeros with the "G" formatting. – Jonathan Wood Nov 19 '14 at 01:41
1

The G29 is not necessary. "G0"=="G29" for decimal – statler Sep 30 '17 at 02:40
What if I don't want it to use scientific notation? – SuperJMN May 23 '19 at 08:58

score 23 · Answer 2 · answered Apr 06 '11 at 11:52

23

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

answered Apr 06 '11 at 11:52

Jason dinAlt

291
3
5

score 4 · Answer 3 · answered Apr 30 '15 at 07:16

Unlike what everybody suggest to use a G format specifier I would suggest the following to preserve both thousand separator and decimal point while removing extra trailing zeros:

{0:#,#.##}

The result of this format is much better than G in most cases:

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

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

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

And the G specifier can't really handle all the possible combinations:

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

score 4 · Answer 4 · answered Jan 24 '11 at 20:21

4

You can specify the format string like this:

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

answered Jan 24 '11 at 20:21

driis

161,458
45
265
341

2

But I don't know that it's got three decimals on the end, I meant that only as an example. I'll make the question clearer. – Scott Stafford Jan 24 '11 at 20:22

score 4 · Answer 5 · edited May 23 '17 at 10:31

They're not necessarily meaningless - they indicate the precision during calculation. Decimals maintain their precision level, rather than being normalized.

I have some code in this answer which will return a normalized value - you could use that, and then format the result. For example:

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 suspect that most of the format string approaches will fail. I would guess that a format string of "0." and then 28 # characters would work, but it would be very ugly...

@Gabe: Unless you use a 3rd party BigInteger implementation, yes. It's also pretty inefficient. On the other hand, it has the advantage of working :) — Jon Skeet, Jan 24 '11 at 20:34

Gabe · Answer 6 · 2011-01-24T21:29:32.427

3

How about:

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

edited Jan 24 '11 at 21:29

answered Jan 24 '11 at 20:43

Gabe

84,912
12
139
238

Use System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator instead of '.'? – Yoshi Jan 24 '11 at 21:26

score 2 · Answer 7 · answered Jan 24 '11 at 20:25

2

Quite a few answers already. I often refer to this cheat sheet: http://blog.stevex.net/string-formatting-in-csharp/

answered Jan 24 '11 at 20:25

Baz Hughes

21
1

Davy8 · Answer 8 · 2011-01-24T20:37:08.110

2

Somewhat hackish, but this should work:

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

edited Jan 24 '11 at 20:37

answered Jan 24 '11 at 20:29

Davy8

30,868
25
115
173

Ack! What if `a = 100.000`? Or `a = 0`? – Gabe Jan 24 '11 at 20:35
@Gabe Was in the process of fixing – Davy8 Jan 24 '11 at 20:37
@kerk should be fixed now. Let me know if you find any counterexamples to the updated answer. – Davy8 Jan 24 '11 at 20:39
Wouldn't mind a downvote removal unless the updated answer still isn't satisfactory? – Davy8 Jan 24 '11 at 20:47

score 1 · Answer 9 · edited Dec 20 '12 at 10:50

1

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

edited Dec 20 '12 at 10:50

Shimmy Weitzhandler

101,809
122
424
632

answered Jan 24 '11 at 20:21

John K.

5,426
1
21
20

Should be... String.Format("{0:0.0##}", 123.456789m) Thanks – John K. Jan 24 '11 at 20:30

score 1 · Answer 10 · answered Jan 24 '11 at 20:23

1

I believe you want to do:

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

answered Jan 24 '11 at 20:23

AlG

14,697
4
41
54

score -3 · Answer 11 · answered Dec 11 '13 at 14:16

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

How do I format a C# decimal to remove extra following 0's?

11 Answers11

Linked