Develop Reference

Prevent C# from using 'E+x' with large numbers [duplicate]

How to convert double to string without the power to 10 representation (E-05)
double value = 0.000099999999833333343;
string text = value.ToString();
Console.WriteLine(text); // 9,99999998333333E-05
I'd like the string text to be 0.000099999999833333343 (or nearly that, I'm not doing rocket science:)
I've tried the following variants
Console.WriteLine(value.ToString()); // 9,99999998333333E-05
Console.WriteLine(value.ToString("R20")); // 9,9999999833333343E-05
Console.WriteLine(value.ToString("N20")); // 0,00009999999983333330
Console.WriteLine(String.Format("{0:F20}", value)); // 0,00009999999983333330
Doing tostring N20 or format F20 seems closest to what I want, but I do end up with a lot of trailing zeros, is there a clever way to avoid this? I'd like to get as close to the double representation as possible 0.000099999999833333343

Use String.Format() with the format specifier. I think you want {0:F20} or so.
string formatted = String.Format("{0:F20}", value);

How about
Convert.ToDecimal(doubleValue).ToString()

You don't need string.Format(). Just put the right format string in the existing .ToString() method. Something like "N" should do.

Use string.Format with an appropriate format specifier.
This blog post has a lot of examples: http://blogs.msdn.com/kathykam/archive/2006/03/29/564426.aspx

String format number with three sections as String.Format(“{0:$#,##0.00;($#,##0.00);Zero}”, value);

I'm implementing string format number with three sections as
DataFormatString="{}{0:$#,##0.00;($#,##0.00);''}"
i.e:
input 120 result $120.00
input -120 result ($120.00)
input 0 result ''
the problem is the dollar sign is hard-coded and I want my app to globalization. I tried some thing like this:
DataFormatString="{}{0:C;C;''}"
but it doesn't help.

Perhaps try taking this approach:
var DataFormatString="$#,##0.00;($#,##0.00);''";
var amount = 1342.56m;
var formatted =
amount
.ToString(DataFormatString)
.Replace("$", CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol);
The only downside is that it won't correctly place the currency symbol at the end of the number if that's the standard for that currency.

You can use the overload of string.Format with IFormatProvider like so:
string DataFormatString="{0:C}";
string output = string.Format(CultureInfo.CreateSpecificCulture("culture"),DataFormatString,input)
Demo
However, as Soner Gonul observes, this still won't generate '' as output for 0.

As far as I know, there is no direct format to supply that 3 results you want for those inputs.
For first two format, you can use The "C" format specifier with en-US culture (which has $ as a CurrencySymbol) using 2 as a precision specifier like;
(120).ToString("C2", CultureInfo.GetCultureInfo("en-US")) // $120.00
(-120).ToString("C2", CultureInfo.GetCultureInfo("en-US")) // ($120.00)
But for 0, this generates $0.00 which is not what you want.
As a better solution, check Enigmativity's answer instead which handles 0 value as well.

Surprising int.ToString output

I have been working on a project, and found an interesting problem:
2.ToString("TE"+"000"); // output = TE000
2.ToString("TR"+"000"); // output = TR002
I also have tried with several strings other than "TE" but all have the same correct output.
Out of curiosity, I am wondering how come this could have happened?

Simply based on Microsoft's documentation, Custom Numeric Format Strings, your strings "TE000" and "TR000" are both custom format strings, but clearly they are parsed differently.
2.ToString("TE000") is just a bug in the formatter; it's going down a buggy path because of the unescaped "E". So it's unexpectedly assuming the whole thing is a literal.
2.ToString("TR000") is being interpreted as an implied "TR" literal plus 3 zero-filled digits for an integer value; therefore, you get "TR002".
If you truly want TE and TR verbatim, the expressions 2.ToString("\"TE\"000") and 2.ToString("\"TR\"000") will accomplish that for you by specifying TE and TR as explicit literals, instead of letting the formatter guess if they are valid format specifiers (and getting it wrong).

The ToString needs to PARSE the format string and understand what to do with it.
Let's take a look to the following examples:
2.ToString("TE000"); //output TE000
2.ToString("E000"); //output 2E+000
2.ToString("0TE000); //output 2TE000
2.ToString("T"); //throws exception
2.ToString("TT"); //output TT
This shows that if the ToString parser can understand at least part of the format, it will assume that the rest is just extra characters to print with it. If the format is invalid for the given number (like when you use a DateTime string format on a number), it will throw an exception. If it can not make sense of the format, it will return the format string itself as the result.

You cannot use a numeric format to achieve a custom format, instead use something like this:
int i = 2;
String.Format("TE{0:X3}", i);

See Custom Numeric Format Strings. The E means the exponent part of the scientific notation of the number. Since 2 is 2E000 in exponential notation, that might explain it.

Formatting strings into groups of 3 digits by periods

I know I can format strings using the String.Format() method. Is it possible to format like this?
Example:
string: 1568
formatted: 1.568
string: 168794521
formatted: 168.794.521
string: 987
formatted: 987
Sorry that I can't make myself more clear.

You can format a number that way, but not a string. For example, if you have an integer value, you can use:
int value = 168794521;
string formatted = value.ToString("N0");
With the proper culture, this will format as shown.
If you are using a string, you would need to convert it. You could also explicitly provide a culture to guarantee "." as a thousands separator:
int value = Int32.Parse("168794521");
string formatted = value.ToString("N0", new CultureInfo("de-DE"));

string someNumericValue = "168794521";
int number = int.Parse(someNumericValue); // error checking might be appropriate
value.ToString("0,0", CultureInfo.CreateSpecificCulture("el-GR"));
This will put points in for thousand specifiers.
It's possible that if you want this, your culture may already do this.

Yes, you can do that. SteveX has written a great blog post on string formatting. You could also look at this blog post, and the MSDN documentation.
You probably want to look at the bottom of this documentation in the "More Resources" section for more info about different types of standard format strings.
Here is the relavant part from the SteveX blog on formatting numbers:
Currency {0:c}
Decimal (Whole number) {0:d}
Scientific {0:e}
Fixed point {0:f}
General {0:g}
Number with commas for thousands {0:n}

Custom Numeric Format Strings: Dynamic Decimal Point

I am trying to format a double in C# such that it uses the thousand separator, and adds digits upto 4 decimal places.
This is straight forward except that I dont want to have the decimal point if it is an integer. Is there a way to do this using the custom numeric format strings rather than an if statement of tenary operator?
Currently I have:
string output = dbl.ToString(dbl == (int)dbl ? "#,##0" : "#,##0.####");
Thanks

I believe your second format string of "#,##0.##" should be exactly what you want -- the # format character is a placeholder that will NOT display zeros.
If you had "#,###.00" then you would get trailing zeros.
test code:
double d = 45.00;
Console.Writeline(d.ToString("#,##0.##"));
Gives output of "45". Setting d to 45.45 gives output "45.45", which sounds like what you're after.
So you had the answer after all! ;)
Incidentally, there's a handy cheat-sheet for format strings (amongst other handy cheat-sheets) at http://john-sheehan.com/blog/net-cheat-sheets/

No, there is not any built-in format string for this. Your current solution is the best way to accomplish this.
MSDN lists both the standard numeric format strings and custom numeric format strings, so you should be able to see for yourself that none directly matches your needs.