C#双列表高效匹配求助：百万级数据筛选性能优化方案

嘿，这个场景我太有共鸣了——用嵌套foreach处理百万级数据碰上千个关键词，那性能简直是灾难！毕竟O(MN)的时间复杂度，10001e6就是10亿次操作，CPU根本扛不住。给你几个从易到难的优化方案，亲测有效：

方案1：预编译正则表达式（最快上手，代码改动最小） #

这是最容易落地的方案，利用.NET正则引擎的预编译优化，把所有关键词合并成一个正则表达式，一次性完成匹配，避免循环每个关键词。

步骤： #

1. 先给list1去重，避免重复匹配相同关键词；
2. 转义关键词中的正则特殊字符（比如$、.这类），防止正则语法错误；
3. 预编译正则表达式，提升重复匹配的效率；
4. 用LINQ筛选list2。

代码示例： #

using System.Text.RegularExpressions;

// 第一步：去重关键词，减少匹配压力
var uniqueKeywords = new HashSet<string>(list1);
// 第二步：构建正则模式，转义特殊字符
var regexPattern = string.Join("|", uniqueKeywords.Select(Regex.Escape));
// 第三步：预编译正则，按需添加IgnoreCase（忽略大小写）
var matchRegex = new Regex(regexPattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
// 第四步：筛选结果
var filteredList = list2.Where(item => matchRegex.IsMatch(item)).ToList();

为什么快？ #

预编译后的正则会被编译成IL代码，比每次循环调用string.Contains快得多，而且正则引擎内部会对多关键词匹配做优化，远胜手动嵌套循环。

方案2：Trie树（前缀树）进阶优化（极致性能） #

如果关键词数量特别多（比如超过1000），或者需要极致性能，可以用Trie树来实现多关键词子串匹配。Trie树可以让我们遍历一次list2的字符串，就同时检查所有关键词是否存在，时间复杂度接近O(M*L)（L是字符串平均长度），比正则更高效。

简单Trie树实现框架： #

public class TrieNode
{
    public Dictionary<char, TrieNode> Children { get; } = new Dictionary<char, TrieNode>();
    public bool IsEndOfWord { get; set; }
}

public class Trie
{
    private readonly TrieNode _root = new TrieNode();

    public void Insert(string word)
    {
        var current = _root;
        foreach (var c in word.ToLower()) // 统一小写，支持忽略大小写
        {
            if (!current.Children.ContainsKey(c))
                current.Children[c] = new TrieNode();
            current = current.Children[c];
        }
        current.IsEndOfWord = true;
    }

    public bool ContainsSubstring(string text)
    {
        var lowerText = text.ToLower();
        for (int i = 0; i < lowerText.Length; i++)
        {
            var current = _root;
            for (int j = i; j < lowerText.Length; j++)
            {
                if (!current.Children.ContainsKey(lowerText[j]))
                    break;
                current = current.Children[lowerText[j]];
                if (current.IsEndOfWord)
                    return true;
            }
        }
        return false;
    }
}

使用示例： #

// 构建Trie树
var trie = new Trie();
foreach (var keyword in list1)
    trie.Insert(keyword);
// 筛选结果
var filteredList = list2.Where(item => trie.ContainsSubstring(item)).ToList();

方案3：并行处理放大优势 #

不管用上面哪种方案，都可以配合**PLINQ（并行LINQ）**利用多核CPU的优势，进一步缩短处理时间。因为list2是百万级数据，并行处理的收益非常明显。

代码示例（配合正则方案）： #

var filteredList = list2.AsParallel()
                        .WithDegreeOfParallelism(Environment.ProcessorCount) // 用满CPU核心
                        .Where(item => matchRegex.IsMatch(item))
                        .ToList();

注意事项： #

• PLINQ的开销在小数据量时可能抵消收益，但百万级数据绝对值得；
• 确保你的匹配逻辑是线程安全的（正则和Trie树都是线程安全的，放心用）。

额外优化细节 #

• 整词匹配需求：如果需要匹配完整单词（比如Cat不能匹配Catty），可以在正则模式中添加单词边界\b，比如：$@"\b{Regex.Escape(k)}\b"；
• 大小写敏感控制：如果不需要忽略大小写，可以去掉RegexOptions.IgnoreCase，或者在Trie树中不用转小写；
• 分批处理：如果list2数据量过大导致内存压力，可以分批读取处理，避免一次性加载全部数据到内存。

内容的提问来源于stack exchange，提问作者Nhan Tran