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

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

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

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

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

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

что, конечно, нонсенс. Только профиль реальные код.

TL; DR: простой foreach - Это самый быстрый способ, чтобы выполнить итерации строку.

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

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

Ниже приведен пример реализации для 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 = '';
            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 = '';
            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 = '';
            var longString = _longString;

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

            return c;
        }

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

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

            return c;
        }

        [Benchmark]
        public unsafe char Unsafe()
        {
            char c = '';
            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 может удалить это, потому что он может сделать вывод, что вы на самом деле не наблюдаете результаты итерации. На | - ing символы в массиве и возвращая это, BenchmarkDotNet будет убедиться, что JIT не может выполнить это оптимизация.

Если микро оптимизация очень важна для вас, то попробуйте это. (Я предположил, что длина входной строки кратна 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++;
        }
    }
}

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

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

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