C＃：如何将十进制转换为字符串而不转换为指数表示

Question

For instance, I have an object array with some values. It can be decimal, double ,int or strings. object[] oo = {0.000278121, 0.000078125m, "Hello",1}; For instance when converting this values to string, the second value becomes 7.8125E-05. But first value stays as in array. So how to differentiate parsing logic for that types, and parse all decimal values in the same format? Full code:

object[] oo = {0.000278121, 0.000078125,"Hello",1};
string[] ss = oo.Select(x => x.ToString()).ToArray();
Console.WriteLine(string.Join("|",ss)); // 0.000278121|7.8125E-05

Answer 1

Firstly, that's not a decimal , it's a double . Use 0.000278121m, 0.000078125m if you want decimal s.

To force a full length string representation without exponentials use .ToString("0.#################") for double. With decimal the default does this so .ToString() as you have would work fine.

Answer 2

Instead of below line:

string[] ss = oo.Select(x => x.ToString()).ToArray();

You can use below line your code:

I am assuming that 10 is maximum number of decimal digits you can have in the input sets. If there are more then change N10 to some other number.

string[] ss = oo.Select(x => ((double)x).ToString("N10")).ToArray();

Answer 3

If you have a disparate collection of objects, treat each type differently:

var outStrings = new List<string>();
object[] oo = { 0.000278121, 0.000078125, "Hello World" };
foreach (var ooItem in oo) {
    if (ooItem is double dOo) {
        outStrings.Add(dOo.ToString("0.#################"));
    } else {
        outStrings.Add(ooItem.ToString());
    }
}

If you have many types that you want to treat individually, use a pattern matching switch statement

Answer 4

I believe you could use double.ToString(string) method. See: https://docs.microsoft.com/en-us/dotnet/api/system.double.tostring?view=netframework-4.7.2#System_Double_ToString_System_String_

The parameter can be either custom numeric format strings ( https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings ) or standard numeric format strings ( https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings?view=netframework-4.7.2#NFormatString ).

The precision specifier of "N" format specifier should be between 0 and 99 (N0 ~ N99), otherwise the ToString method will return the string passed as parameter instead. You could do double.ToString("N99") , which will return the string in numeric form in its highest precision. The problem with this is that if you do 0.000078125.ToString("N99") , the output would have lots of trailing 0s, like: 0.0000781250000000000... .

To overcome this, you could use string.TrimEnd(char) method. 0.000078125.ToString("N99").TrimEnd('0') will trim the trailing zeros, so the output can be 0.000078125.

In the given example code, this can be applied as:

//Avoid boxing - specify types whenever possible, or use generic
double[] oo = {0.000278121, 0.000078125};
string[] ss = oo.Select(x => x.ToString("N99").TrimEnd('0')).ToArray();
Console.WriteLine(string.Join("|",ss)); // 0.000278121|0.000078125

Edit: I should have read the question more carefully, changing the type of oo would not be suitable in your case. However, the general idea is the same; Cast the object to double, Use ToString(string) method with appropriate precision, then trim the trailing zeros.

You can check that the type of object is double by doing obj is double , and furthermore, cast it back to double by obj is double dbl (Pattern matching).

Edit 2:

public static IEnumerable<string> AllToString(IEnumerable<object> objArray)
{
    foreach (object obj in objArray)
    {
        switch (obj)
        {
            case double dbl:
                yield return dbl.ToString("N99").TrimEnd('0');
                break;
            case bool b:
                yield return b.ToString();
                break;
            case int i:
                yield return i.ToString();
                break;
            case short s:
                yield return s.ToString();
                break;
            case string str:
                yield return str;
                break;
            case float flt:
                yield return flt.ToString("N99").TrimEnd('0');
                break;
            case decimal dcm:
                yield return dcm.ToString("N99").TrimEnd('0');
                break;
            case byte bt:
                yield return bt.ToString();
                break;
            case char ch:
                yield return ch.ToString();
                break;
            case uint ui:
                yield return ui.ToString();
                break;
            case ushort us:
                yield return us.ToString();
                break;
            case sbyte sb:
                yield return sb.ToString();
                break;
            case long ln:
                yield return ln.ToString();
                break;
            case ulong uln:
                yield return uln.ToString();
                break;
            case null:
                yield return null; //new string()?
                break;
            case DateTime dt:
                yield return dt.ToString();
                break;
            case TimeSpan ts:
                yield return ts.ToString();
                break;
            default: //Fallback
                yield return obj.ToString();
                break;
        }
    }
}

Pass the object array to the method, then call .ToArray() or .ToList() if required. This will convert every item in the array/list of object to a collection of strings.