基于OpenXml的C# Docx文本替换失效问题及解决方法问询

为什么官方SearchAndReplace会失效？ #

Word文档的XML结构中，视觉上连续的文本可能被拆分为多个<w:r>（Run）节点，原因包括：

• 编辑过程中多次修改格式（即使最终格式一致）
• 从其他文档复制粘贴文本
• Word自动的文本分段优化

官方的SearchAndReplace方法只检查单个<w:t>（Text）节点内的文本，无法识别跨多个<w:r>节点拼接出的目标字符串，导致替换失效。

如何判断多个文本片段属于同一显示内容？ #

判断的核心依据是文本在同一段落内的连续性：

1. 所有待判断的<w:t>节点必须属于同一个<w:p>（Paragraph）节点
2. 这些<w:t>所在的<w:r>节点在段落内是连续的，中间没有插入非文本元素（如<w:tab>、<w:br>、<w:pict>等）
3. 拼接这些<w:t>的文本后，能形成连续的目标字符串（如{{Number}}）

简单来说：同一段落内、无中断元素的连续<w:r>节点中的文本，属于同一显示内容。

修改C#替换方法实现稳定生效 #

要实现稳定替换，需要在段落级别拼接文本，定位目标字符串后再处理对应的XML节点，同时保留原有格式。以下是完整的实现代码：

辅助类定义 #

// 存储文本片段的位置、对应的XML节点信息
private class TextSegment
{
    public int StartIndex { get; set; }
    public int Length { get; set; }
    public Text TextNode { get; set; }
    public Run RunNode { get; set; }
}

核心替换方法 #

using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System.Collections.Generic;
using System.Linq;

public static void StableTextReplace(WordprocessingDocument doc, string oldText, string newText)
{
    // 遍历文档所有段落
    foreach (var paragraph in doc.MainDocumentPart.Document.Descendants<Paragraph>())
    {
        var segments = new List<TextSegment>();
        int currentTextIndex = 0;

        // 收集当前段落的所有有效文本片段
        foreach (var run in paragraph.Descendants<Run>())
        {
            foreach (var textNode in run.Descendants<Text>())
            {
                if (!string.IsNullOrEmpty(textNode.Text))
                {
                    segments.Add(new TextSegment
                    {
                        StartIndex = currentTextIndex,
                        Length = textNode.Text.Length,
                        TextNode = textNode,
                        RunNode = run
                    });
                    currentTextIndex += textNode.Text.Length;
                }
            }
        }

        // 拼接段落完整文本，查找目标字符串
        string fullParagraphText = string.Concat(segments.Select(s => s.TextNode.Text));
        int matchStartPos = fullParagraphText.IndexOf(oldText, StringComparison.Ordinal);

        while (matchStartPos != -1)
        {
            int matchEndPos = matchStartPos + oldText.Length;
            // 找出所有被目标字符串覆盖的文本片段
            var affectedSegments = segments.Where(s => 
                s.StartIndex < matchEndPos && s.StartIndex + s.Length > matchStartPos).ToList();

            if (affectedSegments.Any())
            {
                // 复用第一个受影响片段的格式，创建新的Run节点
                var sourceRun = affectedSegments.First().RunNode;
                var newRun = sourceRun.RunProperties != null
                    ? new Run(new RunProperties(sourceRun.RunProperties.CloneNode(true)), new Text(newText))
                    : new Run(new Text(newText));

                // 处理第一个片段：保留匹配前的文本（如果有的话）
                var firstSegment = affectedSegments.First();
                if (firstSegment.StartIndex < matchStartPos)
                {
                    firstSegment.TextNode.Text = firstSegment.TextNode.Text.Substring(0, matchStartPos - firstSegment.StartIndex);
                }
                else
                {
                    firstSegment.RunNode.Remove();
                }

                // 处理中间的片段：直接删除（完全被匹配覆盖）
                foreach (var middleSegment in affectedSegments.Skip(1).Take(affectedSegments.Count - 2))
                {
                    middleSegment.RunNode.Remove();
                }

                // 处理最后一个片段：保留匹配后的文本（如果有的话）
                if (affectedSegments.Count > 1)
                {
                    var lastSegment = affectedSegments.Last();
                    if (lastSegment.StartIndex + lastSegment.Length > matchEndPos)
                    {
                        lastSegment.TextNode.Text = lastSegment.TextNode.Text.Substring(matchEndPos - lastSegment.StartIndex);
                    }
                    else
                    {
                        lastSegment.RunNode.Remove();
                    }
                }

                // 插入新的Run节点到合适位置
                if (firstSegment.RunNode.Parent != null)
                {
                    firstSegment.RunNode.InsertAfterSelf(newRun);
                }
                else if (affectedSegments.LastOrDefault()?.RunNode.Parent != null)
                {
                    affectedSegments.Last().RunNode.InsertAfterSelf(newRun);
                }
                else
                {
                    paragraph.AppendChild(newRun);
                }
            }

            // 重新收集片段，继续查找下一个匹配
            segments.Clear();
            currentTextIndex = 0;
            foreach (var run in paragraph.Descendants<Run>())
            {
                foreach (var textNode in run.Descendants<Text>())
                {
                    if (!string.IsNullOrEmpty(textNode.Text))
                    {
                        segments.Add(new TextSegment
                        {
                            StartIndex = currentTextIndex,
                            Length = textNode.Text.Length,
                            TextNode = textNode,
                            RunNode = run
                        });
                        currentTextIndex += textNode.Text.Length;
                    }
                }
            }
            fullParagraphText = string.Concat(segments.Select(s => s.TextNode.Text));
            matchStartPos = fullParagraphText.IndexOf(oldText, matchStartPos + newText.Length, StringComparison.Ordinal);
        }
    }

    // 保存修改
    doc.MainDocumentPart.Document.Save();
}

方法说明 #

1. 段落级处理：确保不会遗漏跨<w:r>节点的文本匹配
2. 格式保留：复用目标字符串所在第一个Run的格式，保证替换后的文本格式与原文本一致
3. 完整覆盖：处理部分匹配的文本片段（截断剩余文本）、完全覆盖的片段（直接删除），确保替换后XML结构合理
4. 循环查找：处理段落内所有匹配的目标字符串，避免遗漏

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