Каков самый быстрый способ перебора отдельных символов в строке на С#?

Ответ 1

Самый быстрый ответ - использовать С++/CLI: Как получить доступ к символам в системе:: String

Этот подход выполняет итерацию через символы на месте в строке, используя арифметику указателя. Нет копий, неявных проверок диапазона и никаких вызовов функций для каждого элемента.

Вероятно, можно получить (почти, С++/CLI не требует закрепления) той же производительности с С#, написав небезопасную версию С# PtrToStringChars.

Что-то вроде:

unsafe char* PtrToStringContent(string s, out GCHandle pin)
{
    pin = GCHandle.Alloc(s, GCHandleType.Pinned);
    return (char*)pin.AddrOfPinnedObject().Add(System.Runtime.CompilerServices.RuntimeHelpers.OffsetToStringData).ToPointer();
}

Не забудьте позвонить GCHandle.Free после этого. Забастовкa >

Комментарий CodeInChaos указывает на то, что С# предоставляет синтаксический сахар для этого:

fixed(char* pch = s) { ... }

Ответ 2

Любая причина не включать foreach?

foreach (char c in text)
{
    ...
}

Неужели это будет ваше узкое место в производительности, кстати? Какая доля вашего общего времени выполнения занимает сама итерация?

Ответ 3

Эти искусственные тесты довольно опасны. Примечательно, что ваши // 2 и//3 версии кода никогда не индексируют строку. Оптимизатор джиттера просто отбрасывает код, поскольку переменная c не используется вообще. Вы просто измеряете, сколько времени занимает цикл for(). Вы не можете это увидеть, если не посмотрите на сгенерированный машинный код.

Измените его на c += longString[i];, чтобы принудительно использовать индексатор массива.

Это, конечно, нонсенс. Профиль только реального кода.

Ответ 4

TL; DR: простой foreach - самый быстрый способ итерации строки.

Для людей, возвращающихся к этому: времена меняются!

С новейшим 64-разрядным JIT.NET, небезопасная версия на самом деле самая медленная.

Ниже приводится эталонная реализация для BenchmarkDotNet. Из этого я получил следующие результаты:

          Method |      Mean |     Error |    StdDev |
---------------- |----------:|----------:|----------:|
        Indexing | 5.9712 us | 0.8738 us | 0.3116 us |
 IndexingOnArray | 8.2907 us | 0.8208 us | 0.2927 us |
  ForEachOnArray | 8.1919 us | 0.6505 us | 0.1690 us |
         ForEach | 5.6946 us | 0.0648 us | 0.0231 us |
          Unsafe | 7.2952 us | 1.1050 us | 0.3941 us |

Интересными являются те, которые не работают с копией массива. Это показывает, что индексирование и foreach очень схожи по производительности, разница 5%, foreach быстрее. Использование unsafe на самом деле на 28% медленнее, чем при использовании foreach.

В прошлом unsafe, возможно, был самым быстрым вариантом, но JIT все быстрее и умнее.

В качестве эталона используется эталонный код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Horology;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;

namespace StringIterationBenchmark
{
    public class StringIteration
    {
        public static void Main(string[] args)
        {
            var config = new ManualConfig();

            config.Add(DefaultConfig.Instance);

            config.Add(Job.Default
                .WithLaunchCount(1)
                .WithIterationTime(TimeInterval.FromMilliseconds(500))
                .WithWarmupCount(3)
                .WithTargetCount(6)
            );

            BenchmarkRunner.Run<StringIteration>(config);
        }

        private readonly string _longString = BuildLongString();

        private static string BuildLongString()
        {
            var sb = new StringBuilder();
            var random = new Random();

            while (sb.Length < 10000)
            {
                char c = (char)random.Next(char.MaxValue);
                if (!Char.IsControl(c))
                    sb.Append(c);
            }

            return sb.ToString();
        }

        [Benchmark]
        public char Indexing()
        {
            char c = '\0';
            var longString = _longString;
            int strLength = longString.Length;

            for (int i = 0; i < strLength; i++)
            {
                c |= longString[i];
            }

            return c;
        }

        [Benchmark]
        public char IndexingOnArray()
        {
            char c = '\0';
            var longString = _longString;
            int strLength = longString.Length;
            char[] charArray = longString.ToCharArray();

            for (int i = 0; i < strLength; i++)
            {
                c |= charArray[i];
            }

            return c;
        }

        [Benchmark]
        public char ForEachOnArray()
        {
            char c = '\0';
            var longString = _longString;

            foreach (char item in longString.ToCharArray())
            {
                c |= item;
            }

            return c;
        }

        [Benchmark]
        public char ForEach()
        {
            char c = '\0';
            var longString = _longString;

            foreach (char item in longString)
            {
                c |= item;
            }

            return c;
        }

        [Benchmark]
        public unsafe char Unsafe()
        {
            char c = '\0';
            var longString = _longString;
            int strLength = longString.Length;

            fixed (char* p = longString)
            {
                var p1 = p;

                for (int i = 0; i < strLength; i++)
                {
                    c |= *p1;
                    p1++;
                }
            }

            return c;
        }
    }
}

В коде есть несколько незначительных изменений от предлагаемого кода. Шрифты, которые извлекаются из исходной строки, | -ed с возвращаемой переменной, и мы возвращаем значение. Причина этого в том, что нам действительно нужно что-то сделать с результатом. В противном случае, если бы мы просто повторяли строку, например:

//8 foreach (c in string)
foreach (char c in longString) { } 

JIT может удалить это, потому что он может сделать вывод о том, что вы фактически не наблюдаете результаты итерации. По | -показав символы в массиве и вернув это, BenchmarkDotNet удостоверится, что JIT не может выполнить эту оптимизацию.

Ответ 5

Если для вас очень важна микро-оптимизация, попробуйте это. (Я предположил, что длина входной строки кратна 8 для простоты)

unsafe void LoopString()
{
    fixed (char* p = longString)
    {
        char c1,c2,c3,c4;
        Int64 len = longString.Length;
        Int64* lptr = (Int64*)p;
        Int64 l;
        for (int i = 0; i < len; i+=8)
        {
            l = *lptr;
            c1 = (char)(l & 0xffff);
            c2 = (char)(l >> 16);
            c3 = (char)(l >> 32);
            c4 = (char)(l >> 48);
            lptr++;
        }
    }
}

Просто шутите, никогда не используйте этот код:)

Ответ 6

Если скорость действительно имеет значение for быстрее, чем foreach

for (int i = 0; i < text.Length; i++) {
   char ch = text[i];
   ...
}