ओपनएक्सएमएल सभी दस्तावेज़ों में पाठ को प्रतिस्थापित करता है

Question

मेरे पास नीचे कोड का टुकड़ा है। मैं "टेक्स्ट 1" टेक्स्ट को "न्यूटेक्स्ट" द्वारा प्रतिस्थापित करना चाहता हूं, यह काम है। लेकिन जब मैं एक तालिका में "टेक्स्ट 1" टेक्स्ट डालता हूं जो तालिका के अंदर "टेक्स्ट 1" के लिए अब काम नहीं करता है।

मैं इस दस्तावेज़ को सभी दस्तावेज़ों में बनाना चाहता हूं।

using (WordprocessingDocument doc = WordprocessingDocument.Open(String.Format("c:\\temp\\filename.docx"), true)) 
{ 
    var body = doc.MainDocumentPart.Document.Body; 

    foreach (var para in body.Elements<Paragraph>()) 
    { 
     foreach (var run in para.Elements<Run>()) 
     { 
      foreach (var text in run.Elements<Text>()) 
      { 
       if (text.Text.Contains("##Text1##")) 
        text.Text = text.Text.Replace("##Text1##", "NewText"); 
      } 
     } 
    } 
} 

Answer 1

क्योंकि तालिका तत्व (w:tbl) में एक पैराग्राफ तत्व (w:p) निहित नहीं होने पर आपका कोड काम नहीं करता। अधिक जानकारी के लिए निम्नलिखित MSDN आलेख देखें।

Text वर्ग (w:t के रूप में श्रृंखलाबद्ध) आम तौर पर एक शब्द दस्तावेज़ में एक Run तत्व के भीतर शाब्दिक पाठ प्रतिनिधित्व करता है। तो अगर आप बस सभी w:t तत्वों के लिए खोज (Text वर्ग) और अपने टैग को बदलने सकता है अगर पाठ तत्व (w:t) अपने टैग है:

using (WordprocessingDocument doc = WordprocessingDocument.Open("yourdoc.docx", true)) 
{ 
    var body = doc.MainDocumentPart.Document.Body; 

    foreach (var text in body.Descendants<Text>()) 
    { 
    if (text.Text.Contains("##Text1##")) 
    { 
     text.Text = text.Text.Replace("##Text1##", "NewText"); 
    } 
    } 
} 

Answer 2

हो सकता है कि इस समाधान आसान

using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(document, true)) 
{ 
string docText = null; 
//1. Copy all the file into a string 
using (StreamReader sr = new StreamReader(wordDoc.MainDocumentPart.GetStream())) 
    docText = sr.ReadToEnd(); 

//2. Use regular expression to replace all text 
Regex regexText = new Regex(find); 
docText = regexText.Replace(docText, replace); 

//3. Write the changed string into the file again 
using (StreamWriter sw = new StreamWriter(wordDoc.MainDocumentPart.GetStream(FileMode.Create))) 
     sw.Write(docText); 

Answer 3

पर उधार है विभिन्न स्थानों में कुछ अन्य उत्तरों, और इस तथ्य के साथ कि चार मुख्य बाधाओं को दूर किया जाना चाहिए:

1. किसी भी hig को हटाएं आपकी प्रतिस्थापन स्ट्रिंग से एच स्तर यूनिकोड वर्ण जिन्हें Word (खराब उपयोगकर्ता इनपुट से) से पढ़ा नहीं जा सकता है
2. अनुच्छेद के भीतर एकाधिक रन या टेक्स्ट तत्वों में आपके खोज परिणाम की खोज करने की क्षमता (शब्द अक्सर कई वाक्यों में एक वाक्य को तोड़ देगा टेक्स्ट रन)
3. दस्तावेज़ में बहु-पंक्ति पाठ डालने के लिए अपने प्रतिस्थापन टेक्स्ट में एक लाइन ब्रेक शामिल करने की क्षमता।
4. किसी भी नोड में अपनी खोज के शुरुआती बिंदु के रूप में पास करने की क्षमता ताकि दस्तावेज़ के उस भाग (जैसे शरीर, हेडर, पाद लेख, एक विशिष्ट तालिका, तालिका पंक्ति, या टेबलसेल) पर खोज को प्रतिबंधित किया जा सके। ।

मुझे यकीन है कि बुकमार्क, जटिल घोंसले के उन्नत परिदृश्यों को इस पर अधिक संशोधन की आवश्यकता होगी, लेकिन यह अब तक चलने वाले मूल शब्द दस्तावेज़ों के प्रकार के लिए काम कर रहा है, और मेरे लिए बहुत उपयोगी है अनदेखा रन पूरी तरह से या पूरी फ़ाइल पर एक RegEx का उपयोग कर किसी विशिष्ट टेबलसेल या दस्तावेज़ भाग (उन्नत परिदृश्यों के लिए) को लक्षित करने की कोई क्षमता नहीं है।

उदाहरण उपयोग:

var body = document.MainDocumentPart.Document.Body; 
ReplaceText(body, replace, with); 

कोड:

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

namespace My.Web.Api.OpenXml 
{ 
    public static class WordTools 
    { 


/// <summary> 
     /// Find/replace within the specified paragraph. 
     /// </summary> 
     /// <param name="paragraph"></param> 
     /// <param name="find"></param> 
     /// <param name="replaceWith"></param> 
     public static void ReplaceText(Paragraph paragraph, string find, string replaceWith) 
     { 
      var texts = paragraph.Descendants<Text>(); 
      for (int t = 0; t < texts.Count(); t++) 
      { // figure out which Text element within the paragraph contains the starting point of the search string 
       Text txt = texts.ElementAt(t); 
       for (int c = 0; c < txt.Text.Length; c++) 
       { 
        var match = IsMatch(texts, t, c, find); 
        if (match != null) 
        { // now replace the text 
         string[] lines = replaceWith.Replace(Environment.NewLine, "\r").Split('\n', '\r'); // handle any lone n/r returns, plus newline. 

         int skip = lines[lines.Length - 1].Length - 1; // will jump to end of the replacement text, it has been processed. 

         if (c > 0) 
          lines[0] = txt.Text.Substring(0, c) + lines[0]; // has a prefix 
         if (match.EndCharIndex + 1 < texts.ElementAt(match.EndElementIndex).Text.Length) 
          lines[lines.Length - 1] = lines[lines.Length - 1] + texts.ElementAt(match.EndElementIndex).Text.Substring(match.EndCharIndex + 1); 

         txt.Space = new EnumValue<SpaceProcessingModeValues>(SpaceProcessingModeValues.Preserve); // in case your value starts/ends with whitespace 
         txt.Text = lines[0]; 

         // remove any extra texts. 
         for (int i = t + 1; i <= match.EndElementIndex; i++) 
         { 
          texts.ElementAt(i).Text = string.Empty; // clear the text 
         } 

         // if 'with' contained line breaks we need to add breaks back... 
         if (lines.Count() > 1) 
         { 
          OpenXmlElement currEl = txt; 
          Break br; 

          // append more lines 
          var run = txt.Parent as Run; 
          for (int i = 1; i < lines.Count(); i++) 
          { 
           br = new Break(); 
           run.InsertAfter<Break>(br, currEl); 
           currEl = br; 
           txt = new Text(lines[i]); 
           run.InsertAfter<Text>(txt, currEl); 
           t++; // skip to this next text element 
           currEl = txt; 
          } 
          c = skip; // new line 
         } 
         else 
         { // continue to process same line 
          c += skip; 
         } 
        } 
       } 
      } 
     } 



     /// <summary> 
     /// Determine if the texts (starting at element t, char c) exactly contain the find text 
     /// </summary> 
     /// <param name="texts"></param> 
     /// <param name="t"></param> 
     /// <param name="c"></param> 
     /// <param name="find"></param> 
     /// <returns>null or the result info</returns> 
     static Match IsMatch(IEnumerable<Text> texts, int t, int c, string find) 
     { 
      int ix = 0; 
      for (int i = t; i < texts.Count(); i++) 
      { 
       for (int j = c; j < texts.ElementAt(i).Text.Length; j++) 
       { 
        if (find[ix] != texts.ElementAt(i).Text[j]) 
        { 
         return null; // element mismatch 
        } 
        ix++; // match; go to next character 
        if (ix == find.Length) 
         return new Match() { EndElementIndex = i, EndCharIndex = j }; // full match with no issues 
       } 
       c = 0; // reset char index for next text element 
      } 
      return null; // ran out of text, not a string match 
     } 

     /// <summary> 
     /// Defines a match result 
     /// </summary> 
     class Match 
     { 
      /// <summary> 
      /// Last matching element index containing part of the search text 
      /// </summary> 
      public int EndElementIndex { get; set; } 
      /// <summary> 
      /// Last matching char index of the search text in last matching element 
      /// </summary> 
      public int EndCharIndex { get; set; } 
     } 

    } // class 
} // namespace 


public static class OpenXmlTools 
    { 
     // filters control characters but allows only properly-formed surrogate sequences 
     private static Regex _invalidXMLChars = new Regex(
      @"(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F\uFEFF\uFFFE\uFFFF]", 
      RegexOptions.Compiled); 
     /// <summary> 
     /// removes any unusual unicode characters that can't be encoded into XML which give exception on save 
     /// </summary> 
     public static string RemoveInvalidXMLChars(string text) 
     { 
      if (string.IsNullOrEmpty(text)) return ""; 
      return _invalidXMLChars.Replace(text, ""); 
     } 
    }