基于C# 12与.NET 8的同义词组匹配查询方案咨询

针对你的需求，结合C# 12和.NET 8特性，推荐两种更高效简洁的实现方案，均基于预构建辅助结构提升查找效率：

方案一：字典映射+快速位置定位 #

利用静态初始化的字典，将每个同义词映射到其所属组，同时兼顾单词索引与原字符串字符位置的获取：

public static class SynonymMatcher
{
    private static readonly string[][] _synonymGroups = new[]
    {
        new[] { "food", "grub", "meal" },
        new[] { "cat", "feline" }
    };

    private static Dictionary<string, (string[] Group, int GroupIndex)> _synonymToGroup = null!;

    // .NET 8模块初始化器，程序启动时一次性构建字典
    [ModuleInitializer]
    internal static void InitializeSynonymMap()
    {
        _synonymToGroup = new Dictionary<string, (string[], int)>();
        for (int groupIdx = 0; groupIdx < _synonymGroups.Length; groupIdx++)
        {
            var group = _synonymGroups[groupIdx];
            foreach (var word in group)
            {
                _synonymToGroup[word] = (group, groupIdx);
            }
        }
    }

    public static (string? FoundWord, string[]? Group, int WordIndex, int CharStartPos, int CharEndPos)? FindMatch(string input)
    {
        var inputWords = input.Split(' ');
        int wordIndex = -1;
        string? matchedWord = null;
        (string[] Group, int GroupIndex) groupInfo = default;

        // 遍历单词数组，找到第一个匹配项即退出
        for (int i = 0; i < inputWords.Length; i++)
        {
            if (_synonymToGroup.TryGetValue(inputWords[i], out groupInfo))
            {
                wordIndex = i;
                matchedWord = inputWords[i];
                break;
            }
        }

        if (matchedWord == null)
            return null;

        // 计算原字符串中的字符起止位置
        int startPos = input.IndexOf(matchedWord);
        int endPos = startPos + matchedWord.Length - 1;

        return (matchedWord, groupInfo.Group, wordIndex, startPos, endPos);
    }
}

优势 #

• 字典预构建完成后，单次查找耗时O(1)，遍历单词数组因仅存在一个匹配项，实际效率接近O(1)
• 代码逻辑直观，无需处理正则转义，适合纯空格分隔单词的输入场景
• 模块初始化器替代静态构造函数，初始化时机更可控，符合.NET 8最佳实践

方案二：正则匹配+字典映射 #

适合输入含标点符号（如"i ate grub!"）的场景，通过正则匹配完整单词，再映射到所属组：

public static class SynonymMatcherRegex
{
    private static readonly string[][] _synonymGroups = new[]
    {
        new[] { "food", "grub", "meal" },
        new[] { "cat", "feline" }
    };

    private static Dictionary<string, string[]> _synonymToGroup = null!;
    private static Regex _synonymRegex = null!;

    [ModuleInitializer]
    internal static void Initialize()
    {
        _synonymToGroup = new Dictionary<string, string[]>();
        var escapedSynonyms = new List<string>();

        foreach (var group in _synonymGroups)
        {
            foreach (var word in group)
            {
                _synonymToGroup[word] = group;
                escapedSynonyms.Add(Regex.Escape(word));
            }
        }

        // 构建单词边界匹配正则，确保仅匹配完整单词
        string pattern = $@"\b(?:{string.Join("|", escapedSynonyms)})\b";
        _synonymRegex = new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
    }

    public static (string? FoundWord, string[]? Group, int CharStartPos, int CharEndPos, int? WordIndex)? FindMatch(string input)
    {
        var match = _synonymRegex.Match(input);
        if (!match.Success)
            return null;

        string matchedWord = match.Value;
        var group = _synonymToGroup[matchedWord];

        // 可选：获取单词在空格拆分数组中的索引
        int? wordIndex = input.Split(' ').ToList().IndexOf(matchedWord);

        return (matchedWord, group, match.Index, match.Index + match.Length - 1, wordIndex);
    }
}

优势 #

• 支持含标点的输入场景，正则\b确保匹配完整单词，避免部分匹配
• 正则预编译后，多次匹配效率稳定
• 同样通过字典O(1)定位所属组

方案选择 #

• 若输入为纯空格分隔的单词，优先选择方案一，代码更简洁高效
• 若输入可能包含标点或复杂单词边界，选择方案二，兼容性更强

内容的提问来源于stack exchange，提问作者Kjell Rilbe