Update Word Template Dynamically using Open XML

using System.Data;

using System.Text;
using System.IO;
using System.Xml;
using DocumentFormat.OpenXml.Packaging;

using DocumentFormat.OpenXml;

// use this method in you Page
DataTable dtDoc = new DataTable();
dtDoc =CreateDocDataTable();
SearchAndReplace(Sourctfilepath, DestinationfilePath, dtDoc);


//Creating Data table
public DataTable CreateDocDataTable()
    {
        DataTable dtDoc = new DataTable();
        DataColumn dcKey_Name = new DataColumn("Key_Name");
        DataColumn dcOutputValue = new DataColumn("OutputValue");
        dtDoc.Columns.Add(dcKey_Name);
        dtDoc.Columns.Add(dcOutputValue);

        DataRow drContractRef = dtDoc.NewRow();
        drContractRef["Key_Name"] = "<<ContractRef#>>";

       drContractRef["OutputValue"] = "value" ;

       dtDoc.Rows.Add(drContractRef);
     
        return dtDoc;

}



    public static byte[] StreamFile(string filename)
    {
        FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);

        // Create a byte array of file stream length
        byte[] FileData = new byte[fs.Length];

        //Read block of bytes from stream into the byte array
        fs.Read(FileData, 0, System.Convert.ToInt32(fs.Length));

        //Close the File Stream
        fs.Close();
        return FileData; //return the byte data
    }

//Save Output file with Memory Stream
    public static void SaveMemoryStream(MemoryStream ms, string FileName)
    {
        FileStream outStream = File.OpenWrite(FileName);
        ms.WriteTo(outStream);
        outStream.Flush();
        outStream.Close();
    }


//Search and Replace data in Word document
 public static void SearchAndReplace(string strSourcePath, string outPutFilepath, DataTable dtKey_Vlaues)
    {

        //SPFile objSpFile = myWeb.GetFile(strSourcePath);
        //byte[] fileByteDoc = objSpFile.OpenBinary();


        byte[] fileByteDoc = StreamFile(strSourcePath);
        MemoryStream streamSource = new MemoryStream();
        streamSource.Write(fileByteDoc, 0, (int)fileByteDoc.Length);

        using (var mainDoc = WordprocessingDocument.Open(streamSource, false))


        using (MemoryStream outPutMemStream = new MemoryStream())
        {
            using (var resultDoc = WordprocessingDocument.Create(outPutMemStream,
              WordprocessingDocumentType.Document))
            {
                // copy parts from source document to new document
                foreach (var part in mainDoc.Parts)
                    resultDoc.AddPart(part.OpenXmlPart, part.RelationshipId);
                // perform replacements in resultDoc.MainDocumentPart
                // ...
            }
            using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(outPutMemStream, true))
            {
                string docText = null;
                using (StreamReader sr = new StreamReader(wordDoc.MainDocumentPart.GetStream()))
                {
                    docText = sr.ReadToEnd();
                }
                XmlDocument xmlDoc;
                xmlDoc = GetXmlDocument(wordDoc.MainDocumentPart.DocumentSettingsPart);
                XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
                nsmgr.AddNamespace("w",
                    "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
                XmlNodeList trackedRevisions =
                    xmlDoc.SelectNodes("descendant::w:trackRevisions", nsmgr);
                if (trackedRevisions.Count > 0)
                    throw new SearchAndReplaceException(
                        "Revision tracking is turned on for document.");

                xmlDoc = GetXmlDocument(wordDoc.MainDocumentPart);
                foreach (DataRow theRow in dtKey_Vlaues.Rows)
                {
                    SearchAndReplaceInXmlDocument(xmlDoc, theRow["Key_Name"].ToString(), strReturnDate(theRow["OutputValue"].ToString()), true);
                }
                PutXmlDocument(wordDoc.MainDocumentPart, xmlDoc);

                int headerpartscount = wordDoc.MainDocumentPart.HeaderParts.Count();
                foreach (var headerpart in wordDoc.MainDocumentPart.HeaderParts)
                {

                    xmlDoc = GetXmlDocument(headerpart);

                    foreach (DataRow theRow in dtKey_Vlaues.Rows)
                    {
                        SearchAndReplaceInXmlDocument(xmlDoc, theRow["Key_Name"].ToString(), strReturnDate(theRow["OutputValue"].ToString()), true);
                    }
                    PutXmlDocument(headerpart, xmlDoc);
                }


                //myWeb.Files.Add(outPutFilepath, outPutMemStream, true);

                SaveMemoryStream(outPutMemStream, outPutFilepath);

                //outPutMemStream.Close();  //closed in the above function                      
                wordDoc.Close();
                wordDoc.Dispose();
            }
        }


    }


    private static string strReturnDate(string strDate)
    {
        string strReturn = string.Empty;
        try
        {

            return strReturn = string.Format("{0:dd-MMM-yyyy}", Convert.ToDateTime(strDate));
        }
        catch (Exception ex)
        {
            return strDate;
        }
    }

//Creating base class method for exceptions
    public class SearchAndReplaceException : Exception
    {
        public SearchAndReplaceException(string message) : base(message) { }
    }

//Fetching data in XML Format on Word document
    public static XmlDocument GetXmlDocument(OpenXmlPart part)
    {
        XmlDocument xmlDoc = new XmlDocument();
        using (Stream partStream = part.GetStream())
        using (XmlReader partXmlReader = XmlReader.Create(partStream))
            xmlDoc.Load(partXmlReader);
        return xmlDoc;
    }

//Search and Replace Data in XML Format
private static void SearchAndReplaceInXmlDocument(XmlDocument xmlDocument, string search, string replace, bool matchCase)
    {

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDocument.NameTable);
        nsmgr.AddNamespace("w",
            "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
        var paragraphs = xmlDocument.SelectNodes("descendant::w:p", nsmgr);
        foreach (var paragraph in paragraphs)
            SearchAndReplaceInParagraph((XmlElement)paragraph, search, replace, matchCase);
    }

//Open file and Write data in XML Format
    public static void PutXmlDocument(OpenXmlPart part, XmlDocument xmlDoc)
    {
        using (Stream partStream = part.GetStream(FileMode.Create, FileAccess.Write))
        using (XmlWriter partXmlWriter = XmlWriter.Create(partStream))
            xmlDoc.Save(partXmlWriter);
    }

// Search and Replace data in XML Format
static void SearchAndReplaceInParagraph(XmlElement paragraph, string search, string replace, bool matchCase)
    {
        try
        {
            XmlDocument xmlDoc = paragraph.OwnerDocument;
            string wordNamespace =
                "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
            XmlNamespaceManager nsmgr =
                new XmlNamespaceManager(xmlDoc.NameTable);
            nsmgr.AddNamespace("w", wordNamespace);
            XmlNodeList paragraphText = paragraph.SelectNodes("descendant::w:t", nsmgr);
            StringBuilder sb = new StringBuilder();
            foreach (XmlNode text in paragraphText)
                sb.Append(((XmlElement)text).InnerText);
            if (sb.ToString().Contains(search) ||
                (!matchCase && sb.ToString().ToUpper().Contains(search.ToUpper())))
            {
                XmlNodeList runs = paragraph.SelectNodes("child::w:r", nsmgr);
                foreach (XmlElement run in runs)
                {
                    XmlNodeList childElements = run.SelectNodes("child::*", nsmgr);
                    if (childElements.Count > 0)
                    {
                        XmlElement last = (XmlElement)childElements[childElements.Count - 1];
                        for (int c = childElements.Count - 1; c >= 0; --c)
                        {
                            if (childElements[c].Name == "w:rPr")
                                continue;
                            if (childElements[c].Name == "w:t")
                            {
                                string textElementString = childElements[c].InnerText;
                                for (int i = textElementString.Length - 1; i >= 0; --i)
                                {
                                    XmlElement newRun =
                                        xmlDoc.CreateElement("w:r", wordNamespace);
                                    XmlElement runProps =
                                        (XmlElement)run.SelectSingleNode("child::w:rPr", nsmgr);
                                    if (runProps != null)
                                    {
                                        XmlElement newRunProps =
                                            (XmlElement)runProps.CloneNode(true);
                                        newRun.AppendChild(newRunProps);
                                    }
                                    XmlElement newTextElement =
                                        xmlDoc.CreateElement("w:t", wordNamespace);
                                    XmlText newText =
                                        xmlDoc.CreateTextNode(textElementString[i].ToString());
                                    newTextElement.AppendChild(newText);
                                    if (textElementString[i] == ' ')
                                    {
                                        XmlAttribute xmlSpace = xmlDoc.CreateAttribute(
                                            "xml", "space",
                                            "http://www.w3.org/XML/1998/namespace");
                                        xmlSpace.Value = "preserve";
                                        newTextElement.Attributes.Append(xmlSpace);
                                    }
                                    newRun.AppendChild(newTextElement);
                                    paragraph.InsertAfter(newRun, run);
                                }
                            }
                            else
                            {
                                XmlElement newRun = xmlDoc.CreateElement("w:r", wordNamespace);
                                XmlElement runProps =
                                    (XmlElement)run.SelectSingleNode("child::w:rPr", nsmgr);
                                if (runProps != null)
                                {
                                    XmlElement newRunProps =
                                        (XmlElement)runProps.CloneNode(true);
                                    newRun.AppendChild(newRunProps);
                                }
                                XmlElement newChildElement =
                                    (XmlElement)childElements[c].CloneNode(true);
                                newRun.AppendChild(newChildElement);
                                paragraph.InsertAfter(newRun, run);
                            }
                        }
                        paragraph.RemoveChild(run);
                    }
                }

                while (true)
                {
                    bool cont = false;
                    runs = paragraph.SelectNodes("child::w:r", nsmgr);
                    for (int i = 0; i <= runs.Count - search.Length; ++i)
                    {
                        bool match = true;
                        for (int c = 0; c < search.Length; ++c)
                        {
                            XmlElement textElement =
                                (XmlElement)runs[i + c].SelectSingleNode("child::w:t", nsmgr);
                            if (textElement == null)
                            {
                                match = false;
                                break;
                            }
                            if (textElement.InnerText == search[c].ToString())
                                continue;
                            if (!matchCase &&
                                textElement.InnerText.ToUpper() == search[c].ToString().ToUpper())
                                continue;
                            match = false;
                            break;
                        }
                        if (match)
                        {
                            XmlElement runProps =
                                (XmlElement)runs[i].SelectSingleNode("descendant::w:rPr", nsmgr);
                            XmlElement newRun = xmlDoc.CreateElement("w:r", wordNamespace);
                            if (runProps != null)
                            {
                                XmlElement newRunProps = (XmlElement)runProps.CloneNode(true);
                                newRun.AppendChild(newRunProps);
                            }
                            XmlElement newTextElement =
                                xmlDoc.CreateElement("w:t", wordNamespace);
                            XmlText newText = xmlDoc.CreateTextNode(replace);
                            newTextElement.AppendChild(newText);
                            if (replace[0] == ' ' || replace[replace.Length - 1] == ' ')
                            {
                                XmlAttribute xmlSpace = xmlDoc.CreateAttribute("xml", "space",
                                    "http://www.w3.org/XML/1998/namespace");
                                xmlSpace.Value = "preserve";
                                newTextElement.Attributes.Append(xmlSpace);
                            }
                            newRun.AppendChild(newTextElement);
                            paragraph.InsertAfter(newRun, (XmlNode)runs[i]);
                            for (int c = 0; c < search.Length; ++c)
                                paragraph.RemoveChild(runs[i + c]);
                            cont = true;
                            break;
                        }
                    }
                    if (!cont)
                        break;
                }

                // Consolidate adjacent runs that have only text elements, and have the
                // same run properties. This isn't necessary to create a valid document,
                // however, having the split runs is a bit messy.
                XmlNodeList children = paragraph.SelectNodes("child::*", nsmgr);
                List<int> matchId = new List<int>();
                int id = 0;
                for (int c = 0; c < children.Count; ++c)
                {
                    if (c == 0)
                    {
                        matchId.Add(id);
                        continue;
                    }
                    if (children[c].Name == "w:r" &&
                        children[c - 1].Name == "w:r" &&
                        children[c].SelectSingleNode("w:t", nsmgr) != null &&
                        children[c - 1].SelectSingleNode("w:t", nsmgr) != null)
                    {
                        XmlElement runProps =
                            (XmlElement)children[c].SelectSingleNode("w:rPr", nsmgr);
                        XmlElement lastRunProps =
                            (XmlElement)children[c - 1].SelectSingleNode("w:rPr", nsmgr);
                        if ((runProps == null && lastRunProps != null) ||
                            (runProps != null && lastRunProps == null))
                        {
                            matchId.Add(++id);
                            continue;
                        }
                        if (runProps != null && runProps.InnerXml != lastRunProps.InnerXml)
                        {
                            matchId.Add(++id);
                            continue;
                        }
                        matchId.Add(id);
                        continue;
                    }
                    matchId.Add(++id);
                }

                for (int i = 0; i <= id; ++i)
                {
                    var x1 = matchId.IndexOf(i);
                    var x2 = matchId.LastIndexOf(i);
                    if (x1 == x2)
                        continue;
                    StringBuilder sb2 = new StringBuilder();
                    for (int z = x1; z <= x2; ++z)
                        sb2.Append(((XmlElement)children[z]
                            .SelectSingleNode("w:t", nsmgr)).InnerText);
                    XmlElement newRun = xmlDoc.CreateElement("w:r", wordNamespace);
                    XmlElement runProps =
                        (XmlElement)children[x1].SelectSingleNode("child::w:rPr", nsmgr);
                    if (runProps != null)
                    {
                        XmlElement newRunProps = (XmlElement)runProps.CloneNode(true);
                        newRun.AppendChild(newRunProps);
                    }
                    XmlElement newTextElement = xmlDoc.CreateElement("w:t", wordNamespace);
                    XmlText newText = xmlDoc.CreateTextNode(sb2.ToString());
                    newTextElement.AppendChild(newText);
                    if (sb2[0] == ' ' || sb2[sb2.Length - 1] == ' ')
                    {
                        XmlAttribute xmlSpace = xmlDoc.CreateAttribute(
                            "xml", "space", "http://www.w3.org/XML/1998/namespace");
                        xmlSpace.Value = "preserve";
                        newTextElement.Attributes.Append(xmlSpace);
                    }
                    newRun.AppendChild(newTextElement);
                    paragraph.InsertAfter(newRun, children[x2]);
                    for (int z = x1; z <= x2; ++z)
                        paragraph.RemoveChild(children[z]);
                }

                var txbxParagraphs = paragraph.SelectNodes("descendant::w:p", nsmgr);
                foreach (XmlElement p in txbxParagraphs)
                    SearchAndReplaceInParagraph((XmlElement)p, search, replace, matchCase);
            }
        }
        catch (Exception ex)
        {

        }
    }