Более быстрая альтернатива decimal.Parse

Я заметил, что decimal.Parse(number, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture) примерно на 100% медленнее, чем пользовательский метод десятичного разбора, основанный на коде Джеффри Сакса из Более быстрая альтернатива 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));
}

Я предполагаю, что это потому, что native decimal.Parse предназначен для борьбы с типом номера и информацией о культуре.

Однако вышеупомянутый метод не использует 3-й параметр hi byte в new decimal, поэтому он не будет работать с большими числами.

Есть ли более быстрая альтернатива decimal.Parse для преобразования строки, состоящей только из чисел и десятичной точки в десятичную, что будет работать с большими числами?

EDIT: контрольный показатель:

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.

ОТВЕТЫ

Ответ 1

Спасибо за все ваши комментарии, которые дали мне немного больше понимания. Наконец я сделал это следующим образом. Если вход слишком длинный, он отделяет входную строку и обрабатывает первую часть с использованием длинной, а остальная - с 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

input: 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,. и необязательно - в начале, тогда эта пользовательская функция значительно быстрее для разбора строки до десятичной.

Ответ 2

Метод Sax выполняется по двум причинам. Первое, вы уже знаете. Во-вторых, это потому, что он может использовать очень эффективный 8-байтовый длинный тип данных для n. Понимание этого метода использования длинного, также может объяснить, почему (к сожалению) в настоящее время невозможно использовать подобный метод для очень больших чисел.

Первые два параметра: lo и mid в десятичном конструкторе используют по 4 байта каждый. Вместе это тот же объем памяти, что и длинный. Это означает, что вам не остается свободного места, если вы нажмете максимальное значение надолго.

Чтобы использовать подобный метод, вам понадобится 12-байтовый тип данных вместо длинного. Это предоставит вам дополнительные четыре байта, необходимые для использования параметра hi.

Метод Sax очень умный, но пока кто-то не напишет 12-байтовый тип данных, вам просто придется полагаться на decimal.Parse.

Ответ 3

Поскольку этот метод может использоваться для использования больших чисел, я написал метод, который также может заполнять большие числа. Следуя шаблону TryParse, также легко получить дешевые ранние выходы при неверном вводе.

public static class Parser
{
    /// <summary>Parses a decimal.</summary>
    /// <param name="str">
    /// The input string.
    /// </param>
    /// <param name="dec">
    /// The parsed decimal.
    /// </param>
    /// <returns>
    /// True if parsable, otherwise false.
    /// </returns>
    public static bool ToDecimal(string str, out decimal dec)
    {
        dec = default;
        if (string.IsNullOrEmpty(str))
        {
            return false;
        }

        var start = 0;
        var end = str.Length;
        var buffer = 0L;
        var negative = false;
        byte scale = 255;

        int lo = 0;
        int mid = 0;
        var block = 0;

        if (str[0] == '-')
        {
            start = 1;
            negative = true;
        }

        for (var i = start; i < end; i++)
        {
            var ch = str[i];

            // Not a digit.
            if (ch < '0' || ch > '9')
            {
                // if a dot and not found yet.
                if(ch == '.' && scale == 255)
                {
                    scale = 0;
                    continue;
                }
                return false;
            }
            unchecked
            {
                buffer *= 10;
                buffer += ch - '0';

                // increase scale if found.
                if (scale != 255)
                {
                    scale++;
                }
            }

            // Maximum decimals allowed is 28.
            if(scale > 28)
            {
                return false;
            }
            // No longer fits an int.
            if ((buffer & 0xFFFF00000000) != 0)
            {
                if (block == 0)
                {
                    lo = unchecked((int)buffer);
                }
                else if (block == 1)
                {
                    mid = unchecked((int)buffer);
                }
                // Does not longer fits block 2, so overflow.
                else if (block == 2)
                {
                    return false;
                }
                buffer >>= 32;
                block++;
            }
        }

        var hi = unchecked((int)buffer);
        dec = new decimal(lo, mid, hi, negative, scale == 255 ? default : scale);
        return true;
    }
}

И эталон:

Duration: 1.930.358 Ticks (193,04 ms), Decimal.TryParse().
Runs: 2,000,000 Avg: 0,965 Ticks/run
Duration: 319.794 Ticks (31,98 ms), Parser.ToDecimal().
Runs: 2,000,000 Avg: 0,160 Ticks/run

Так что в 6,0 раз быстрее.