比decimal.Parse更快的替代方法

Question

我注意到 decimal.Parse(number, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture) 的速度比基于Jeffrey Sax代码的自定义十进制解析方法慢了大约100%。Jeffrey Sax代码来源于“Convert.ToDouble的更快替代方案”

public static decimal ParseDecimal(string input) {
    bool negative = false;
    long n = 0;

    int len = input.Length;
    int decimalPosition = len;

    if (len != 0) {
        int start = 0;
        if (input[0] == '-') {
            negative = true;
            start = 1;
        }

        for (int k = start; k < len; k++) {
            char c = input[k];

            if (c == '.') {
                decimalPosition = k +1;
            } else {
                n = (n *10) +(int)(c -'0');
            }
        }
    }

    return new decimal(((int)n), ((int)(n >> 32)), 0, negative, (byte)(len -decimalPosition));
}

我认为这是因为原生的 decimal.Parse 方法旨在处理数字样式和文化信息。

然而，上述方法没有使用 new decimal 中的第三个参数高字节，所以无法用于更大的数字。

是否有一种更快的替代方法来将仅由数字和小数点组成的字符串转换为可以处理大数字的十进制数？

编辑：基准测试：

var style = System.Globalization.NumberStyles.AllowDecimalPoint;
var culture = System.Globalization.CultureInfo.InvariantCulture;
System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
s.Reset();
s.Start();
for (int i=0; i<10000000; i++)
{
    decimal.Parse("20000.0011223344556", style, culture);
}
s.Stop();
Console.WriteLine(s.Elapsed.ToString());

s.Reset();
s.Start();
for (int i=0; i<10000000; i++)
{
    ParseDecimal("20000.0011223344556");
}
s.Stop();
Console.WriteLine(s.Elapsed.ToString());

输出：

00:00:04.2313728
00:00:01.4464048

在这种情况下，自定义的ParseDecimal比decimal.Parse快得多。

- LukAss741

---

Decimal.Parse()的速度已经足够快了，它是用C++编写的，并且已经内置在操作系统中20年了。除了取巧以外，你无法提高它的速度。你没有明确说明哪些类型的错误可以接受。 - Hans Passant

如果你想要进行优化，那么输入值的统计分布是你的朋友。例如，如果大多数输入值都是1个字符的字符串，那么你可以编写一个更简单/更快速的转换代码（你甚至不必处理符号字符）来处理这种情况。如果负值很少见，那么转换为仅正值的代码将更快；你可能需要测试一次符号，但如果不存在，则不必再测试其值。我会查看你的输入值分布，并看看是否可以利用它。 - Ira Baxter

在我看来，这应该属于[codereview.se]。 - Thomas Ayoub

@AntonínLejsek：啊，我没意识到。好的，乘以10是正确的做法。我的错误。 - Ira Baxter

在我的电脑上，速度只快了2倍。此外，如果你在真正的代码中使用所有这些（如果你不仅仅是进行基准测试），差异往往会几乎完全消失。Jeffrey Sax的代码或多或少是“解析64位、转换为十进制并移动浮点数”，你很难比CLR做得更好（CLR内部使用不安全的代码/指针来处理完整的128位十进制数）。 - Simon Mourier

Answer 1

感谢所有的评论，这为我提供了更多的见解。最终，我按照以下方式完成。如果输入太长，则将输入字符串分隔并使用 long 解析第一部分，用 int 解析剩余部分，这仍比 decimal.Parse 更快。

这是我的最终生产代码：

public static int[] powof10 = new int[10]
{
    1,
    10,
    100,
    1000,
    10000,
    100000,
    1000000,
    10000000,
    100000000,
    1000000000
};
public static decimal ParseDecimal(string input)
{
    int len = input.Length;
    if (len != 0)
    {
        bool negative = false;
        long n = 0;
        int start = 0;
        if (input[0] == '-')
        {
            negative = true;
            start = 1;
        }
        if (len <= 19)
        {
            int decpos = len;
            for (int k = start; k < len; k++)
            {
                char c = input[k];
                if (c == '.')
                {
                    decpos = k +1;
                }else{
                    n = (n *10) +(int)(c -'0');
                }
            }
            return new decimal((int)n, (int)(n >> 32), 0, negative, (byte)(len -decpos));
        }else{
            if (len > 28)
            {
                len = 28;
            }
            int decpos = len;
            for (int k = start; k < 19; k++)
            {
                char c = input[k];
                if (c == '.')
                {
                    decpos = k +1;
                }else{
                    n = (n *10) +(int)(c -'0');
                }
            }
            int n2 = 0;
            bool secondhalfdec = false; 
            for (int k = 19; k < len; k++)
            {
                char c = input[k];
                if (c == '.')
                {
                    decpos = k +1;
                    secondhalfdec = true;
                }else{
                    n2 = (n2 *10) +(int)(c -'0');
                }
            }
            byte decimalPosition = (byte)(len -decpos);
            return new decimal((int)n, (int)(n >> 32), 0, negative, decimalPosition) *powof10[len -(!secondhalfdec ? 19 : 20)] +new decimal(n2, 0, 0, negative, decimalPosition);
        }
    }
    return 0;
}

基准测试代码：

const string input = "[inputs are below]";
var style = System.Globalization.NumberStyles.AllowDecimalPoint | System.Globalization.NumberStyles.AllowLeadingSign;
var culture = System.Globalization.CultureInfo.InvariantCulture;
System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
s.Reset();
s.Start();
for (int i=0; i<10000000; i++)
{
    decimal.Parse(input, style, culture);
}
s.Stop();
Console.WriteLine(s.Elapsed.ToString());

s.Reset();
s.Start();
for (int i=0; i<10000000; i++)
{
    ParseDecimal(input);
}
s.Stop();
Console.WriteLine(s.Elapsed.ToString());

我的 i7 920 的测试结果如下：

输入：123.456789

00:00:02.7292447
00:00:00.6043730

输入：999999999999999123.456789

00:00:05.3094786
00:00:01.9702198

输入: 1.0

00:00:01.4212123
00:00:00.2378833

输入: 0

00:00:01.1083770
00:00:00.1899732

输入：-3.3333333333333333333333333333333

00:00:06.2043707
00:00:02.0373628

如果输入只包含0-9、.和可选的-（在开头），那么使用此自定义函数将更快地将字符串解析为十进制数。

- LukAss741

Answer 2

Sax的方法之所以快速，有两个原因。第一个原因你已经知道了。第二个原因是因为它能够利用非常高效的8字节长数据类型来处理n。理解这种方法对长整型的使用，也可以解释为什么（不幸的是）目前无法使用类似的方法处理非常大的数字。

十进制构造函数中的前两个参数：lo和mid每个使用4个字节。这样加起来就与long一样多的内存。这意味着一旦达到long的最大值，就没有剩余空间继续进行下去。

要使用类似的方法，您需要使用12字节数据类型代替long。这将为您提供额外的四个字节，以利用hi参数。

Sax的方法非常聪明，但在有人编写12字节数据类型之前，您只能依靠decimal.Parse。

- Brandon Griffin

---

你的陈述是错误的。看看我的实现。在长缓冲区中，您不需要同时拥有所有位。 - Corniel Nobel