用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实际上比使用foreach慢28%。

在过去，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无法执行此优化。

最快的答案是使用C++/CLI:如何：访问系统中的字符：：字符串

这种方法使用指针算术对字符串中的字符进行迭代。没有副本，没有隐式范围检查，也没有每个元素的函数调用。

通过编写PtrToStringChars的不安全的C#版本，很可能从C#获得（几乎不需要固定C++/CLI）相同的性能。

类似于：

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。

CodeInChaos的评论指出，C#为此提供了语法糖：

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

如果速度真的很重要，for比foreach 快

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

如果微优化对您来说非常重要，那么尝试一下。（为了简单起见，我假设输入字符串的长度是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++;
        }
    }
}

只是开玩笑，永远不要使用这个代码：）