无科学记数的双字符串转换

81

.NET Framework中如何在没有科学符号的情况下将双精度转换为浮点字符串表示形式？

“小”样本（有效数字可以是任何大小，例如1.5E200或1e-200）： 

3248971234698200000000000000000000000000000000
0.00000000000000000000000000000000000023897356978234562

没有一种标准的数字格式是这样的，并且自定义格式似乎也不允许在小数点分隔符之后使用开放的数字位数。

这不是重复如何双转换为字符串没有权力代表10（E-05） ，因为那里给出的答案也不会在手解决问题。这个问题可接受的解决方案是使用固定点（例如20位数字），这不是我想要的。定点格式和修剪冗余0并不能解决问题，因为固定宽度的最大宽度为99个字符。

注意：解决方案必须正确处理自定义数字格式（例如，其他小数点分隔符，具体取决于区域性信息）。

编辑：问题实际上只是关于替换上述数字。我知道浮点数如何工作以及可以使用和计算哪些数字。

c#  .net  floating-point  number-formatting 
— 卢塞罗
source
1
您现在对此问题有解决方案吗？
— 基拉2015年
@Anand，有两个有效的解决方案（Paul Sasik和我的），即使它们不是太“不错”（通过字符串操作）。
— Lucero 2015年

Answers:

41

对于通用¹解决方案，您需要保留339个位置：

doubleValue.ToString("0." + new string('#', 339))

非零十进制数字的最大数目为16。15在小数点的右侧。指数最多可以将那15个数字向右移动324个位。（请参阅范围和精度。）

它的工作原理为double.Epsilon，double.MinValue，double.MaxValue，和任何之间。

由于所有格式和字符串工作都是由非托管CLR代码一次性完成的，因此性能将比正则表达式/字符串处理解决方案好得多。同样，代码更容易证明正确。

为了易于使用并获得更好的性能，请使其不变：

public static class FormatStrings
{
    public const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################";
}

¹更新：我错误地说这也是一种无损解决方案。实际上并非如此，因为ToString除以外的所有格式的常规显示都会舍入r。现场示例。谢谢，@讨厌！如果您需要以定点表示法往返的功能（即，如果您今天正在使用），请参阅Lothing的答案.ToString("r")。

— jnm2
source
不错，很短，但是如果不需要非常大的值，则可以快10倍。见我的回答：stackoverflow.com/a/36204442/143684
— ygoe
谢谢，做得很好。你是一个了不起的人。已投票。
— 史努比（Snoop）
1
这种解决方案不是“无懈可击”的。示例：String t1 = (0.0001/7).ToString("0." + new string('#', 339)); // 0.0000142857142857143vs：String t2 = (0.0001/7).ToString("r"); // 1.4285714285714287E-05精度在小数点后位丢失。
— 厌恶
30

我有一个类似的问题，这对我有用：

doubleValue.ToString("F99").TrimEnd('0')

F99可能会过大，但您会明白的。

— 罗伯特·拉姆
source
1
99是不够的，而且之前和逗号后面有两个工作。
— Lucero
2
TrimEnd('0')足够了，因为char数组是params。也就是说，char传递给的任何TrimEnd都会自动分组为一个数组。
— Grault
99是不是足以让一个通用的解决方案。doubleValue.ToString("0." + new string('#', 339))是无损的。使用value比较这些方法double.Epsilon。
— jnm2
20

这是一个字符串解析解决方案，其中源编号（双精度）被转换为字符串并解析为其组成部分。然后根据规则将其重新组装为全长数字表示形式。它还按要求说明语言环境。

更新：转换测试仅包含一位整数，这是常态，但是该算法也适用于：239483.340901e-20

using System;
using System.Text;
using System.Globalization;
using System.Threading;

public class MyClass
{
    public static void Main()
    {
        Console.WriteLine(ToLongString(1.23e-2));            
        Console.WriteLine(ToLongString(1.234e-5));           // 0.00010234
        Console.WriteLine(ToLongString(1.2345E-10));         // 0.00000001002345
        Console.WriteLine(ToLongString(1.23456E-20));        // 0.00000000000000000100023456
        Console.WriteLine(ToLongString(5E-20));
        Console.WriteLine("");
        Console.WriteLine(ToLongString(1.23E+2));            // 123
        Console.WriteLine(ToLongString(1.234e5));            // 1023400
        Console.WriteLine(ToLongString(1.2345E10));          // 1002345000000
        Console.WriteLine(ToLongString(-7.576E-05));         // -0.00007576
        Console.WriteLine(ToLongString(1.23456e20));
        Console.WriteLine(ToLongString(5e+20));
        Console.WriteLine("");
        Console.WriteLine(ToLongString(9.1093822E-31));        // mass of an electron
        Console.WriteLine(ToLongString(5.9736e24));            // mass of the earth 

        Console.ReadLine();
    }

    private static string ToLongString(double input)
    {
        string strOrig = input.ToString();
        string str = strOrig.ToUpper();

        // if string representation was collapsed from scientific notation, just return it:
        if (!str.Contains("E")) return strOrig;

        bool negativeNumber = false;

        if (str[0] == '-')
        {
            str = str.Remove(0, 1);
            negativeNumber = true;
        }

        string sep = Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator;
        char decSeparator = sep.ToCharArray()[0];

        string[] exponentParts = str.Split('E');
        string[] decimalParts = exponentParts[0].Split(decSeparator);

        // fix missing decimal point:
        if (decimalParts.Length==1) decimalParts = new string[]{exponentParts[0],"0"};

        int exponentValue = int.Parse(exponentParts[1]);

        string newNumber = decimalParts[0] + decimalParts[1];

        string result;

        if (exponentValue > 0)
        {
            result = 
                newNumber + 
                GetZeros(exponentValue - decimalParts[1].Length);
        }
        else // negative exponent
        {
            result = 
                "0" + 
                decSeparator + 
                GetZeros(exponentValue + decimalParts[0].Length) + 
                newNumber;

            result = result.TrimEnd('0');
        }

        if (negativeNumber)
            result = "-" + result;

        return result;
    }

    private static string GetZeros(int zeroCount)
    {
        if (zeroCount < 0) 
            zeroCount = Math.Abs(zeroCount);

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < zeroCount; i++) sb.Append("0");    

        return sb.ToString();
    }
}
— 保罗·萨西克
source
嗯 老实说，我注意到它被否决了，所以我没有仔细检查代码。我刚才读过，你是对的。它们很接近，我只是选择在过程中不使用RegEx并进行了自己的字符串解析。您是否测试过此解决方案？这是一个完整的控制台应用程序。
— Paul Sasik，09年
尚未，很快会做...;）
— Lucero，2009年
3
由于您不必使用正则表达式，因此更易于阅读。
— 格雷戈里
+1大声笑@“ grok the regex”我喜欢它。我将使它成为我本土发展的一部分！谢谢。
— Paul Sasik，09年
好吧，Regex至少有一个命名良好的组，而不是某些数组中的未指定索引...;）
— Lucero，2009年
13

您可以将转换double为decimal，然后执行ToString()。

(0.000000005).ToString()   // 5E-09
((decimal)(0.000000005)).ToString()   // 0,000000005

我还没有执行更快的性能测试，可以将其从64位转换double为128位decimal或300多个字符的格式字符串。哦，在转换过程中可能会出现溢出错误，但是如果您的值合适，decimal这应该可以正常工作。

更新：转换似乎要快得多。使用另一个答案中给出的准备好的格式字符串，格式化一百万次需要2.3秒，而转换仅需0.19秒。可重复的。那快10倍。现在只涉及值范围。

— go
source
不幸的是，这对于给定的非常大或很小的数字确实不起作用。((decimal)(1e-200)).ToString()例如返回0错误。
— Lucero
1
为了公平起见，将苹果与苹果进行比较，您应该将此方法与进行比较double.ToString("0.############################")。根据我的测试，您的速度仅快3倍。无论哪种方式，如果您确定不需要在下面打印数字1e-28并且双精度数都不大，那么这只是一个有效的答案，而这两者都不是原始问题的限制。
— jnm2
2
鉴于您知道值范围，这是一个非常不错的解决方案
— Artur Udod
8

到目前为止，这是我目前所能完成的工作，但是也许有人有更好的解决方案：

private static readonly Regex rxScientific = new Regex(@"^(?<sign>-?)(?<head>\d+)(\.(?<tail>\d*?)0*)?E(?<exponent>[+\-]\d+)$", RegexOptions.IgnoreCase|RegexOptions.ExplicitCapture|RegexOptions.CultureInvariant);

public static string ToFloatingPointString(double value) {
    return ToFloatingPointString(value, NumberFormatInfo.CurrentInfo);
}

public static string ToFloatingPointString(double value, NumberFormatInfo formatInfo) {
    string result = value.ToString("r", NumberFormatInfo.InvariantInfo);
    Match match = rxScientific.Match(result);
    if (match.Success) {
        Debug.WriteLine("Found scientific format: {0} => [{1}] [{2}] [{3}] [{4}]", result, match.Groups["sign"], match.Groups["head"], match.Groups["tail"], match.Groups["exponent"]);
        int exponent = int.Parse(match.Groups["exponent"].Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo);
        StringBuilder builder = new StringBuilder(result.Length+Math.Abs(exponent));
        builder.Append(match.Groups["sign"].Value);
        if (exponent >= 0) {
            builder.Append(match.Groups["head"].Value);
            string tail = match.Groups["tail"].Value;
            if (exponent < tail.Length) {
                builder.Append(tail, 0, exponent);
                builder.Append(formatInfo.NumberDecimalSeparator);
                builder.Append(tail, exponent, tail.Length-exponent);
            } else {
                builder.Append(tail);
                builder.Append('0', exponent-tail.Length);
            }
        } else {
            builder.Append('0');
            builder.Append(formatInfo.NumberDecimalSeparator);
            builder.Append('0', (-exponent)-1);
            builder.Append(match.Groups["head"].Value);
            builder.Append(match.Groups["tail"].Value);
        }
        result = builder.ToString();
    }
    return result;
}

// test code
double x = 1.0;
for (int i = 0; i < 200; i++) {
    x /= 10;
}
Console.WriteLine(x);
Console.WriteLine(ToFloatingPointString(x));
— 卢塞罗
source
-1，因为它不提供以下状态的解决方案（并且不能提供）：double d1 = 1e-200; d = d +1; ToFloatingPointString（d）在这里只返回1。不是1,000 ........... 000001
— JCasso
5
将一个数字添加到一个很小的数字只是您的想法，与手头的问题无关。如果仅在没有d = d + 1的情况下运行它，就会看到它确实显示0.000 ..... 0001。
— Lucero
找到一种在运行时计算1e-200的方法，而不是设置“恒定”值，我会投票赞成。
— JCasso
2
没问题。double x = 1.0; for (int i = 0; i < 200; i++) x /= 10; Console.WriteLine(x);
— 卢塞罗（Lucero）
6
那是因为实际上只有15位数字是有意义的，但是您可以使用大或小指数对它们进行“移位”。但是您不能添加一个非常小的数字，该数字要大于约15个数字，因为这样做会超出有效数字的数量，并且由于更大的数字更重要，因此会丢失一小部分。因此，使用相似范围内的数字进行计算（例如添加1e-200和1e-200或1 + 1或1e200 + 1e200）确实可以，但是混合使用这些值将导致较小的值四舍五入。
— Lucero
4

使用#.###...###或的问题F99是，它不能保留末尾小数位的精度，例如：

String t1 = (0.0001/7).ToString("0." + new string('#', 339)); // 0.0000142857142857143
String t2 = (0.0001/7).ToString("r");                         //      1.4285714285714287E-05

问题DecimalConverter.cs在于它很慢。这段代码与Sasik的答案相同，但是速度却快一倍。底部的单元测试方法。

public static class RoundTrip {

    private static String[] zeros = new String[1000];

    static RoundTrip() {
        for (int i = 0; i < zeros.Length; i++) {
            zeros[i] = new String('0', i);
        }
    }

    private static String ToRoundTrip(double value) {
        String str = value.ToString("r");
        int x = str.IndexOf('E');
        if (x < 0) return str;

        int x1 = x + 1;
        String exp = str.Substring(x1, str.Length - x1);
        int e = int.Parse(exp);

        String s = null;
        int numDecimals = 0;
        if (value < 0) {
            int len = x - 3;
            if (e >= 0) {
                if (len > 0) {
                    s = str.Substring(0, 2) + str.Substring(3, len);
                    numDecimals = len;
                }
                else
                    s = str.Substring(0, 2);
            }
            else {
                // remove the leading minus sign
                if (len > 0) {
                    s = str.Substring(1, 1) + str.Substring(3, len);
                    numDecimals = len;
                }
                else
                    s = str.Substring(1, 1);
            }
        }
        else {
            int len = x - 2;
            if (len > 0) {
                s = str[0] + str.Substring(2, len);
                numDecimals = len;
            }
            else
                s = str[0].ToString();
        }

        if (e >= 0) {
            e = e - numDecimals;
            String z = (e < zeros.Length ? zeros[e] : new String('0', e));
            s = s + z;
        }
        else {
            e = (-e - 1);
            String z = (e < zeros.Length ? zeros[e] : new String('0', e));
            if (value < 0)
                s = "-0." + z + s;
            else
                s = "0." + z + s;
        }

        return s;
    }

    private static void RoundTripUnitTest() {
        StringBuilder sb33 = new StringBuilder();
        double[] values = new [] { 123450000000000000.0, 1.0 / 7, 10000000000.0/7, 100000000000000000.0/7, 0.001/7, 0.0001/7, 100000000000000000.0, 0.00000000001,
         1.23e-2, 1.234e-5, 1.2345E-10, 1.23456E-20, 5E-20, 1.23E+2, 1.234e5, 1.2345E10, -7.576E-05, 1.23456e20, 5e+20, 9.1093822E-31, 5.9736e24, double.Epsilon };

        foreach (int sign in new [] { 1, -1 }) {
            foreach (double val in values) {
                double val2 = sign * val;
                String s1 = val2.ToString("r");
                String s2 = ToRoundTrip(val2);

                double val2_ = double.Parse(s2);
                double diff = Math.Abs(val2 - val2_);
                if (diff != 0) {
                    throw new Exception("Value {0} did not pass ToRoundTrip.".Format2(val.ToString("r")));
                }
                sb33.AppendLine(s1);
                sb33.AppendLine(s2);
                sb33.AppendLine();
            }
        }
    }
}
— 讨厌
source
3

基于对数的强制性解决方案。请注意，此解决方案涉及数学运算，因此可能会稍微降低数字的准确性。没有经过严格测试。

private static string DoubleToLongString(double x)
{
    int shift = (int)Math.Log10(x);
    if (Math.Abs(shift) <= 2)
    {
        return x.ToString();
    }

    if (shift < 0)
    {
        double y = x * Math.Pow(10, -shift);
        return "0.".PadRight(-shift + 2, '0') + y.ToString().Substring(2);
    }
    else
    {
        double y = x * Math.Pow(10, 2 - shift);
        return y + "".PadRight(shift - 2, '0');
    }
}

编辑：如果小数点超过数字的非零部分，此算法将惨遭失败。我尝试简单，走得太远了。

— 布赖恩
source
感谢您的输入，我将尝试实现这样一个完全可行的解决方案，并将其与我的进行比较。
— Lucero
3

在过去，我们不得不编写自己的格式化程序时，我们会分离尾数和指数并分别格式化它们。

在乔恩·斯基特（Jon Skeet）（https://csharpindepth.com/articles/FloatingPoint）的这篇文章中，他提供了指向DoubleConverter.cs例程的链接，该例程应该完全执行您想要的操作。Skeet在从c＃中的double中提取尾数和指数时也提到了这一点。

— Ed Power
source
感谢您提供的链接，我已经尝试过Jon的代码，但是出于我的目的，它有点过于精确。例如，0.1不会显示为0.1（从技术上讲这是正确的，但不是我所需要的）……
— Lucero
是的，但是您知道，Jon代码的重点是要精确显示数字，这对我来说太过分了。在执行ToString（）时，由运行时进行的舍入对我来说很好，这也可能就是为什么此处提出的大多数解决方案都将ToString（）用作进一步处理的基础的原因。
— Lucero
你好！未来十年我将来到这里，是为了通知您乔恩文章的超链接已损坏。
— 尼克·瓦卡罗
2

我刚刚对上面的代码进行了即兴创作，以使其适用于负指数值。 

using System;
using System.Text.RegularExpressions;
using System.IO;
using System.Text;
using System.Threading;

namespace ConvertNumbersInScientificNotationToPlainNumbers
{
    class Program
    {
        private static string ToLongString(double input)
        {
            string str = input.ToString(System.Globalization.CultureInfo.InvariantCulture);

            // if string representation was collapsed from scientific notation, just return it:
            if (!str.Contains("E")) return str;

            var positive = true;
            if (input < 0)
            {
                positive = false;
            }

            string sep = Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator;
            char decSeparator = sep.ToCharArray()[0];

            string[] exponentParts = str.Split('E');
            string[] decimalParts = exponentParts[0].Split(decSeparator);

            // fix missing decimal point:
            if (decimalParts.Length == 1) decimalParts = new string[] { exponentParts[0], "0" };

            int exponentValue = int.Parse(exponentParts[1]);

            string newNumber = decimalParts[0].Replace("-", "").
                Replace("+", "") + decimalParts[1];

            string result;

            if (exponentValue > 0)
            {
                if (positive)
                    result =
                        newNumber +
                        GetZeros(exponentValue - decimalParts[1].Length);
                else

                    result = "-" +
                     newNumber +
                     GetZeros(exponentValue - decimalParts[1].Length);


            }
            else // negative exponent
            {
                if (positive)
                    result =
                        "0" +
                        decSeparator +
                        GetZeros(exponentValue + decimalParts[0].Replace("-", "").
                                   Replace("+", "").Length) + newNumber;
                else
                    result =
                    "-0" +
                    decSeparator +
                    GetZeros(exponentValue + decimalParts[0].Replace("-", "").
                             Replace("+", "").Length) + newNumber;

                result = result.TrimEnd('0');
            }
            float temp = 0.00F;

            if (float.TryParse(result, out temp))
            {
                return result;
            }
            throw new Exception();
        }

        private static string GetZeros(int zeroCount)
        {
            if (zeroCount < 0)
                zeroCount = Math.Abs(zeroCount);

            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < zeroCount; i++) sb.Append("0");

            return sb.ToString();
        }

        public static void Main(string[] args)
        {
            //Get Input Directory.
            Console.WriteLine(@"Enter the Input Directory");
            var readLine = Console.ReadLine();
            if (readLine == null)
            {
                Console.WriteLine(@"Enter the input path properly.");
                return;
            }
            var pathToInputDirectory = readLine.Trim();

            //Get Output Directory.
            Console.WriteLine(@"Enter the Output Directory");
            readLine = Console.ReadLine();
            if (readLine == null)
            {
                Console.WriteLine(@"Enter the output path properly.");
                return;
            }
            var pathToOutputDirectory = readLine.Trim();

            //Get Delimiter.
            Console.WriteLine("Enter the delimiter;");
            var columnDelimiter = (char)Console.Read();

            //Loop over all files in the directory.
            foreach (var inputFileName in Directory.GetFiles(pathToInputDirectory))
            {
                var outputFileWithouthNumbersInScientificNotation = string.Empty;
                Console.WriteLine("Started operation on File : " + inputFileName);

                if (File.Exists(inputFileName))
                {
                    // Read the file
                    using (var file = new StreamReader(inputFileName))
                    {
                        string line;
                        while ((line = file.ReadLine()) != null)
                        {
                            String[] columns = line.Split(columnDelimiter);
                            var duplicateLine = string.Empty;
                            int lengthOfColumns = columns.Length;
                            int counter = 1;
                            foreach (var column in columns)
                            {
                                var columnDuplicate = column;
                                try
                                {
                                    if (Regex.IsMatch(columnDuplicate.Trim(),
                                                      @"^[+-]?[0-9]+(\.[0-9]+)?[E]([+-]?[0-9]+)$",
                                                      RegexOptions.IgnoreCase))
                                    {
                                        Console.WriteLine("Regular expression matched for this :" + column);

                                        columnDuplicate = ToLongString(Double.Parse
                                                                           (column,
                                                                            System.Globalization.NumberStyles.Float));

                                        Console.WriteLine("Converted this no in scientific notation " +
                                                          "" + column + "  to this number " +
                                                          columnDuplicate);
                                    }
                                }
                                catch (Exception)
                                {

                                }
                                duplicateLine = duplicateLine + columnDuplicate;

                                if (counter != lengthOfColumns)
                                {
                                    duplicateLine = duplicateLine + columnDelimiter.ToString();
                                }
                                counter++;
                            }
                            duplicateLine = duplicateLine + Environment.NewLine;
                            outputFileWithouthNumbersInScientificNotation = outputFileWithouthNumbersInScientificNotation + duplicateLine;
                        }

                        file.Close();
                    }

                    var outputFilePathWithoutNumbersInScientificNotation
                        = Path.Combine(pathToOutputDirectory, Path.GetFileName(inputFileName));

                    //Create Directory If it does not exist.
                    if (!Directory.Exists(pathToOutputDirectory))
                        Directory.CreateDirectory(pathToOutputDirectory);

                    using (var outputFile =
                        new StreamWriter(outputFilePathWithoutNumbersInScientificNotation))
                    {
                        outputFile.Write(outputFileWithouthNumbersInScientificNotation);
                        outputFile.Close();
                    }

                    Console.WriteLine("The transformed file is here :" +
                        outputFilePathWithoutNumbersInScientificNotation);
                }
            }
        }
    }
}

该代码采用输入目录，并基于定界符将科学计数形式的所有值转换为数字格式。

谢谢

— 平等主义者
source
1

试试这个：

public static string DoubleToFullString(double value, 
                                        NumberFormatInfo formatInfo)
{
    string[] valueExpSplit;
    string result, decimalSeparator;
    int indexOfDecimalSeparator, exp;

    valueExpSplit = value.ToString("r", formatInfo)
                         .ToUpper()
                         .Split(new char[] { 'E' });

    if (valueExpSplit.Length > 1)
    {
        result = valueExpSplit[0];
        exp = int.Parse(valueExpSplit[1]);
        decimalSeparator = formatInfo.NumberDecimalSeparator;

        if ((indexOfDecimalSeparator 
             = valueExpSplit[0].IndexOf(decimalSeparator)) > -1)
        {
            exp -= (result.Length - indexOfDecimalSeparator - 1);
            result = result.Replace(decimalSeparator, "");
        }

        if (exp >= 0) result += new string('0', Math.Abs(exp));
        else
        {
            exp = Math.Abs(exp);
            if (exp >= result.Length)
            {
                result = "0." + new string('0', exp - result.Length) 
                             + result;
            }
            else
            {
                result = result.Insert(result.Length - exp, decimalSeparator);
            }
        }
    }
    else result = valueExpSplit[0];

    return result;
}
— 满济
source
0

由于遍及全球的数百万程序员，尝试搜索是否有人已经遇到您的问题始终是一个好习惯。有时候，解决方案是垃圾，这意味着是时候编写您自己的解决方案了；有时，还有很多解决方案，例如：

http://www.yoda.arachsys.com/csharp/DoubleConverter.cs

（详细信息：http : //www.yoda.arachsys.com/csharp/floatingpoint.html）

— 莱特曼
source
1
这与ebpower已经发布的内容相同，请参阅评论...;）
— Lucero，2009年
0 
string strdScaleFactor = dScaleFactor.ToString(); // where dScaleFactor = 3.531467E-05

decimal decimalScaleFactor = Decimal.Parse(strdScaleFactor, System.Globalization.NumberStyles.Float);
— 普里亚
source
您能否简要解释一下此代码的作用以及它与其他15个左右答案的区别？
— JJJ
欢迎使用Stack Overflow！尽管此代码段可以解决问题，但提供说明确实有助于提高您的帖子质量。请记住，您将来会为读者回答这个问题，而这些人可能不知道您提出代码建议的原因。也请尽量不要在代码中添加解释性注释，这会降低代码和解释的可读性！
— kayess
-1

我可能是错的，但是不是吗？

data.ToString("n");

http://msdn.microsoft.com/zh-CN/library/dwhawy9k.aspx

— csharptest.net
source
看到您的回答，我一定误会了您的问题，对不起。
— csharptest.net，2009年
不，首先，我不要千位分隔符，其次，逗号后似乎总是有固定数量的数字。另请参见N格式的MSDN帮助：msdn.microsoft.com/zh-cn/library/dwhawy9k.aspx#NFormatString
— Lucero，2009年
您还可以在小数点后添加更多（即“ n8”或“ n50”等）。
— BrainSlugs83
-1

只是基于jcasso所说的，您可以做的是通过更改指数来调整您的double值，以便您最喜欢的格式可以为您完成该操作，应用该格式，然后用零填充结果以补偿调整。

— 姆芬戈尔德
source
IEEE浮点数的指数为2基，但是十进制数为10基。因此，这是行不通的。这也是为什么不能将0.1作为精确值存储为双精度值的原因。或者，如果您认为我误解了您的答案，请仅提供一些示例（代码）。
— 卢塞罗（Lucero）
-1

我认为你只需要使用IFormat与 

ToString(doubleVar, System.Globalization.NumberStyles.Number)

例：

double d = double.MaxValue;
string s = d.ToString(d, System.Globalization.NumberStyles.Number);
— 穆罕默德·阿卜杜
source
6
那甚至不编译，您能发布一些编译的东西吗？
— Lucero 2010年
-1

我的解决方案是使用自定义格式。试试这个：

double d;
d = 1234.12341234;
d.ToString("#########0.#########");
— 伊格尔·本·纳坦
source
2
尝试使用我上面给出的测试编号：d = 1.5E200和d = 1E-200。结果字符串中应该包含近200个0字符，否则您的解决方案将无法正常工作。
— Lucero 2012年
对于通用解决方案，小数点后9位是不够的。doubleValue.ToString("0." + new string('#', 339))是无损的。使用value比较这些方法double.Epsilon。
— jnm2
-1

这对我来说很好...

double number = 1.5E+200;
string s = number.ToString("#");

//Output: "150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
1
是的，它适用于大量用户，但不适用于逗号后的任何内容，尤其是不适用于1.5e-200。
— Lucero
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.