如何用C#高效搜索10GB以上大文本文件中的特定字符串？

核心问题分析 #

你当前的方案效率低主要有两个原因：

• 逐行读取会产生大量字符串对象，触发频繁GC，同时string.Contains()默认使用的朴素匹配算法在长文本中效率不高；
• 多线程分割块搜索时，没有处理跨块的字符串匹配，且如果块划分不合理，反而会因IO竞争或线程上下文切换抵消性能收益。

优化方案 #

1. 用内存映射文件（MemoryMappedFile）替代逐行读取

内存映射文件直接将文件内容映射到进程虚拟内存，避免了频繁的磁盘IO和内存拷贝，是处理超大文件的首选方案。结合Span/ReadOnlySpan操作，还能避免不必要的字符串分配，减少GC压力。

示例代码（UTF-8编码文件，直接处理字节）：

using System.IO.MemoryMappedFiles;
using System.Text;

public static List<long> FindStringPositions(string filePath, string target)
{
    var targetBytes = Encoding.UTF8.GetBytes(target);
    var targetLength = targetBytes.Length;
    var positions = new List<long>();

    using (var mmf = MemoryMappedFile.CreateFromFile(filePath, FileMode.Open))
    using (var stream = mmf.CreateViewStream())
    {
        var buffer = new byte[4096 * 1024]; // 4MB缓冲区，可根据内存调整
        long currentPosition = 0;
        int bytesRead;
        int overlap = targetLength - 1; // 处理跨缓冲区的匹配
        byte[] previousOverlap = Array.Empty<byte>();

        while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
        {
            // 合并上一次的重叠区域和当前缓冲区
            var combinedBuffer = new byte[previousOverlap.Length + bytesRead];
            Buffer.BlockCopy(previousOverlap, 0, combinedBuffer, 0, previousOverlap.Length);
            Buffer.BlockCopy(buffer, 0, combinedBuffer, previousOverlap.Length, bytesRead);

            // 在合并后的缓冲区中查找目标字节数组
            int index = 0;
            while ((index = IndexOf(combinedBuffer, targetBytes, index)) != -1)
            {
                // 计算实际文件中的位置（减去重叠区域的长度）
                long filePosition = currentPosition - previousOverlap.Length + index;
                positions.Add(filePosition);
                index += targetLength;
            }

            // 保存当前缓冲区末尾的重叠区域，用于下一次合并
            if (bytesRead >= overlap)
            {
                previousOverlap = new byte[overlap];
                Buffer.BlockCopy(buffer, bytesRead - overlap, previousOverlap, 0, overlap);
            }
            else
            {
                previousOverlap = Array.Empty<byte>();
            }

            currentPosition += bytesRead;
        }
    }

    return positions;
}

// 实现Boyer-Moore字节数组匹配算法，比内置的IndexOf更高效
private static int IndexOf(byte[] haystack, byte[] needle, int startIndex)
{
    if (needle.Length == 0) return startIndex;
    int[] badCharTable = BuildBadCharTable(needle);
    int n = haystack.Length;
    int m = needle.Length;
    int i = startIndex;

    while (i <= n - m)
    {
        int j = m - 1;
        while (j >= 0 && haystack[i + j] == needle[j])
            j--;

        if (j < 0)
            return i;
        else
            i += Math.Max(1, j - badCharTable[haystack[i + j]]);
    }
    return -1;
}

private static int[] BuildBadCharTable(byte[] needle)
{
    int[] table = new int[256];
    Array.Fill(table, -1);
    for (int i = 0; i < needle.Length; i++)
        table[needle[i]] = i;
    return table;
}

2. 优化多线程处理：解决跨块匹配+控制线程数

如果要使用多线程，必须处理跨块的匹配问题——每个块需要额外读取目标字符串长度-1字节的重叠区域。同时，因为文件IO是瓶颈，不要开过多线程（通常等于CPU核心数或核心数×2即可），避免IO竞争。

示例思路：

• 将文件划分为多个块，每个块大小设为64MB~256MB（根据内存调整）；
• 每个块读取时，额外读取末尾的target.Length-1字节，或者前一个块的末尾target.Length-1字节；
• 使用Parallel.For或任务池分配任务，同时用线程安全的集合（如ConcurrentBag<long>）存储结果。

3. 避免编码转换开销

如果文件是UTF-8编码，直接处理字节数组比转换为string/char[]高效得多——编码转换会带来额外的CPU开销和内存分配。如果是其他编码（如GB2312），可以先将目标字符串转为对应编码的字节数组，再进行匹配。

4. 使用高效的匹配算法

内置的string.Contains()或Array.IndexOf()使用的是朴素匹配算法，对于长目标字符串，Boyer-Moore、Rabin-Karp等算法的效率会高出数倍。上面的代码已经实现了Boyer-Moore的字节版，你可以直接复用。

额外优化建议 #

• 禁用文件系统缓存：如果系统内存不足，可通过MemoryMappedFileOptions.DelayAllocatePages减少内存占用，但会降低IO速度；
• 预分配结果集合：提前估算可能的匹配数，用List<long>(capacity)预分配容量，避免动态扩容；
• 避免调试模式：调试模式下CLR会有额外的检查，发布模式运行能显著提升性能。

内容的提问来源于stack exchange，提问作者Volkan Alkılıç