C# XML导出Word方法

发现大家都在用这个帖子的内容，我把原来写的源码上传上来给大家分享
http://download.csdn.net/source/3093041

最近写的一个通过XML导出Word的方法，共大家参考讨论：

方法的调用：

 Dictionary<string, string> wordTexts = new Dictionary<string, string>();
    Dictionary<string, DataTable> wordTable = new Dictionary<string, DataTable>();
WordMLHelper Word = new WordMLHelper();
 wordTexts.Clear();
 wordTexts.Add("XML中书签名称",“导出的内容”);
 Word.SetNodeText(wordTexts);
 DataTable dt=getDateTable（）；//获得一个数据表
 wordTable.Clear();
  wordTable.Add("XML中书签名称", dt);
   Word.SetNodeTable(wordTable);
  Word.Save("存储地址");

操作类的代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Drawing;
using System.IO;
using System.Data;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Collections;
using System.Web;

/// <summary>
/// 导出word
/// Author:FreezeSoul&Worm
/// 操作WordML(2003)根据标签插入文本、表格、图片
/// </summary>
public class WordMLHelper
{
    /// <summary>
    /// 最短路径图片在导出Word文件中的宽度
    /// webconfig中加入节点 <add key ="WordWidth" value="400"/>
    /// </summary>
    public string WordWidth
    {
        get
        {
            return System.Configuration.ConfigurationSettings.AppSettings["WordWidth"].ToString();
        }
    }

    /// <summary>
    /// 最短路径图片在导出Word文件中的高度
    /// webconfig中加入节点<add key ="WordHeight" value="300"/>
    /// </summary>
    public string WordHeight
    {
        get
        {
            return System.Configuration.ConfigurationSettings.AppSettings["WordHeight"].ToString();
        }
    }

    private XmlNamespaceManager nsmgr;
    private XmlDocument xdoc;
    public void CreateXmlDom(string xmlPath)
    {
        xdoc = new XmlDocument();

        xdoc.Load(xmlPath);
        nsmgr = new XmlNamespaceManager(xdoc.NameTable);
        nsmgr.AddNamespace("w", "http://schemas.microsoft.com/office/word/2003/wordml");
        nsmgr.AddNamespace("v", "urn:schemas-microsoft-com:vml");
        nsmgr.AddNamespace("aml", "http://schemas.microsoft.com/aml/2001/core");
        nsmgr.AddNamespace("wx", "http://schemas.microsoft.com/office/word/2003/auxHint");
    }

    string serverPath = HttpContext.Current.Server.MapPath("~");//Replace("../", "\\").Replace("/", "\\")

    #region 导出Word文档的方法

    /// <summary>
    /// 设置节点的值
    /// </summary>
    /// <param name="bookmarks"></param>
    public void SetNodeText(Dictionary<string, string> bookmarks)
    {
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            SetBookMarkTexts(xdoc, node, bookmarks);
        }
    }

    /// <summary>
    /// 根据数据集插入数据,数据集中的数据表含有一条数据
    /// </summary>
    /// <param name="ds"></param>
    public void SetNodeTextDataSet(DataSet ds)
    {
        Dictionary<string, string> bookmarkValues = new Dictionary<string, string>();
        foreach (System.Data.DataTable dt in ds.Tables)
        {
            foreach (DataColumn dc in dt.Columns)
            {
                if (dt.Rows.Count > 0)
                {
                    bookmarkValues.Add(dt.TableName + "_" + dc.ColumnName, dt.Rows[0][dc.ColumnName].ToString());
                }
            }
        }
        SetNodeText(bookmarkValues);
    }

    /// <summary>
    /// 根据数据表插入数据,数据表含有一条数据
    /// </summary>
    /// <param name="ds"></param>
    public void SetNodeTextDataTable(System.Data.DataTable dt)
    {
        Dictionary<string, string> bookmarkValues = new Dictionary<string, string>();

        foreach (DataColumn dc in dt.Columns)
        {
            if (dt.Rows.Count > 0)
            {
                bookmarkValues.Add(dt.TableName + "_" + dc.ColumnName, dt.Rows[0][dc.ColumnName].ToString());
            }
        }
        SetNodeText(bookmarkValues);
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// </summary>
    /// <param name="tables"></param>
    public void SetNodeTable(Dictionary<string, System.Data.DataTable> tables)
    {
        Dictionary<string, WordTable> wordtables = new Dictionary<string, WordTable>();

        foreach (KeyValuePair<string, System.Data.DataTable> table in tables)
        {
            wordtables.Add(table.Key, WordTable.GetWordTabelFromDataTable(table.Value));
        }
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            SetBookMarkTablesHorizontal(xdoc, node, wordtables);
        }
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// </summary>
    /// <param name="wordtables"></param>
    public void SetNodeTable(Dictionary<string, WordTable> wordtables)
    {
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            SetBookMarkTablesHorizontal(xdoc, node, wordtables);
        }
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// </summary>
    /// <param name="tables"></param>
    /// <param name="IsHorizontal">是否为水平列表,即列名在数据上方</param>
    public void SetNodeTable(Dictionary<string, System.Data.DataTable> tables, bool IsHorizontal)
    {
        Dictionary<string, WordTable> wordtables = new Dictionary<string, WordTable>();

        foreach (KeyValuePair<string, System.Data.DataTable> table in tables)
        {
            wordtables.Add(table.Key, WordTable.GetWordTabelFromDataTable(table.Value));
        }
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            if (IsHorizontal)
                SetBookMarkTablesHorizontal(xdoc, node, wordtables);
            else
                SetBookMarkTablesVertical(xdoc, node, wordtables);
        }
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// </summary>
    /// <param name="wordtables"></param>
    /// <param name="IsHorizontal">是否为水平列表,即列名在数据上方</param>
    public void SetNodeTable(Dictionary<string, WordTable> wordtables, bool IsHorizontal)
    {
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            if (IsHorizontal)
                SetBookMarkTablesHorizontal(xdoc, node, wordtables);
            else
                SetBookMarkTablesVertical(xdoc, node, wordtables);
        }
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// 图片的列是传入datatabele的最后一列,且最后一列为图片的绝对地址
    /// </summary>
    /// <param name="tables"></param>
    /// <param name="IsHorizontal">是否为水平列表,即列名在数据上方</param>
    /// <param name="ExistPicture">是否含有图片</param>
    public void SetNodeTable(Dictionary<string, System.Data.DataTable> tables, bool IsHorizontal, bool ExistPicture)
    {
        Dictionary<string, WordTable> wordtables = new Dictionary<string, WordTable>();

        foreach (KeyValuePair<string, System.Data.DataTable> table in tables)
        {
            wordtables.Add(table.Key, WordTable.GetWordTabelFromDataTable(table.Value));
        }
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            if (ExistPicture)
            {
                if (IsHorizontal)
                    SetBookMarkTablesPictureHorizontal(xdoc, node, wordtables);
                else
                    SetBookMarkTablesPictureVertical(xdoc, node, wordtables);
            }
            else
            {
                if (IsHorizontal)
                    SetBookMarkTablesHorizontal(xdoc, node, wordtables);
                else
                    SetBookMarkTablesVertical(xdoc, node, wordtables);
            }
        }
    }

    /// <summary>
    /// 插入一张表数据,表中含有多条数据
    /// 图片的列是传入wordtables的最后一列,且最后一列为图片的绝对地址
    /// </summary>
    /// <param name="wordtables"></param>
    /// <param name="IsHorizontal">是否为水平列表,即列名在数据上方</param>
    /// <param name="ExistPicture">是否含有图片</param>
    public void SetNodeTable(Dictionary<string, WordTable> wordtables, bool IsHorizontal, bool ExistPicture)
    {
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            if (ExistPicture)
            {
                if (IsHorizontal)
                    SetBookMarkTablesPictureHorizontal(xdoc, node, wordtables);
                else
                    SetBookMarkTablesPictureVertical(xdoc, node, wordtables);
            }
            else
            {
                if (IsHorizontal)
                    SetBookMarkTablesHorizontal(xdoc, node, wordtables);
                else
                    SetBookMarkTablesVertical(xdoc, node, wordtables);
            }
        }
    }

    /// <summary>
    /// 设置插入的图品数据
    /// </summary>
    /// <param name="picpaths"></param>
    public void SetNodePic(Dictionary<string, WordPic> picpaths)
    {
        XmlNodeList nodeList = xdoc.SelectNodes("//aml:annotation[@w:type='Word.Bookmark.Start']", nsmgr);
        //XmlNodeList nodeList = xdoc.SelectNodes("//w:bookmarkStart", nsmgr);
        foreach (XmlNode node in nodeList)
        {
            SetBookMarkPics(xdoc, node, picpaths);
        }
    }

    /// <summary>
    /// 保存导出的数据
    /// </summary>
    /// <param name="docPath"></param>
    public void Save(string docPath)
    {
        xdoc.Save(docPath);
    }

    #endregion

    #region 导出word文档内部方法

    /// <summary>
    /// 根据标签插入对应的值
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="bookmarks"></param>
    private void SetBookMarkTexts(XmlDocument xdoc, XmlNode node, Dictionary<string, string> bookmarks)
    {
        //找到bookmark结束标记
        if (node.NextSibling.Name.ToString() == "aml:annotation")
        {
            //查找bookmarks中是否在word标签
            if (bookmarks.ContainsKey(node.Attributes["w:name"].Value))
            {
                //得到node上一个兄弟节点style ("w:rPr")的克隆，以备添给新加内容，样式继承
                XmlNode nodeStyle = null;
                if (node.PreviousSibling != null)
                    nodeStyle = node.PreviousSibling.CloneNode(true);
                else
                    nodeStyle = node.ParentNode.SelectNodes("//w:r", nsmgr)[0].CloneNode(true);
                //父节点 "w:p"
                XmlNode bookmrkParent = node.ParentNode;
                XmlElement tagRun;
                tagRun = xdoc.CreateElement("w:r", nsmgr.LookupNamespace("w"));
                bookmrkParent.AppendChild(tagRun);
                //添加样式
                if (nodeStyle.SelectSingleNode("//w:rPr", nsmgr) != null)
                    tagRun.AppendChild(nodeStyle.SelectSingleNode("//w:rPr", nsmgr));
                XmlElement tagText;
                tagText = xdoc.CreateElement("w:t", nsmgr.LookupNamespace("w"));
                tagRun.AppendChild(tagText);
                //插入(w:t)文本作为内容，追加至文本节点

                if (bookmarks[node.Attributes["w:name"].Value] == null)
                    return;
                XmlNode nodeText;
                nodeText = xdoc.CreateNode(XmlNodeType.Text, "w:t", nsmgr.LookupNamespace("w"));
                nodeText.Value = bookmarks[node.Attributes["w:name"].Value].ToString();
                tagText.AppendChild(nodeText);
            }
        }
    }

    /// <summary>
    /// 根据标签水平插入一张表数据，即列名在数据上侧
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="wordtables"></param>
    private void SetBookMarkTablesHorizontal(XmlDocument xdoc, XmlNode node, Dictionary<string, WordTable> wordtables)
    {
        if (node.NextSibling.Name.ToString() == "aml:annotation")
        {
            //查找bookmarks中是否在word标签
            if (wordtables.ContainsKey(node.Attributes["w:name"].Value))
            {
                // "w:p"节点的父节点
                XmlNode bookmrkParent = node.ParentNode;
                XmlNode bookmrkParentParent = node.ParentNode.ParentNode;
                XmlElement tagtable;
                tagtable = xdoc.CreateElement("w:tbl", nsmgr.LookupNamespace("w"));
                bookmrkParentParent.InsertAfter(tagtable, bookmrkParent);

                SetImportTableBorder(ref xdoc, ref tagtable);

                XmlElement tagtr;
                tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                tagtable.AppendChild(tagtr);

                foreach (string headstr in wordtables[node.Attributes["w:name"].Value].TableHeads)
                {
                    SetTableTitle(ref tagtr, headstr);
                }

                for (int i = 0; i < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(0); i++)
                {
                    tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                    tagtable.AppendChild(tagtr);

                    for (int j = 0; j < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(1); j++)
                    {
                        string content = wordtables[node.Attributes["w:name"].Value].TableValues[i, j];
                        SetTableContent(ref tagtr, content);

                    }
                }
            }
        }
    }

    /// <summary>
    /// 根据标签垂直插入一张表数据，即列名在数据左侧
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="wordtables"></param>
    private void SetBookMarkTablesVertical(XmlDocument xdoc, XmlNode node, Dictionary<string, WordTable> wordtables)
    {
        if (node.NextSibling.Name.ToString() == "aml:annotation")
        {
            //查找bookmarks中是否在word标签
            if (wordtables.ContainsKey(node.Attributes["w:name"].Value))
            {
                // "w:p"节点的父节点
                XmlNode bookmrkParent = node.ParentNode;
                XmlNode bookmrkParentParent = node.ParentNode.ParentNode;
                XmlElement tagtable;
                tagtable = xdoc.CreateElement("w:tbl", nsmgr.LookupNamespace("w"));
                bookmrkParentParent.InsertAfter(tagtable, bookmrkParent);

                //设置表格样式
                SetImportTableBorder(ref xdoc, ref tagtable);

                for (int i = 0; i < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(0); i++)
                {
                    for (int j = 0; j < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(1); j++)
                    {
                        XmlElement tagtr;
                        tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                        tagtable.AppendChild(tagtr);
                        if (wordtables[node.Attributes["w:name"].Value].TableHeads[j] == null)
                            return;
                        string headstr = wordtables[node.Attributes["w:name"].Value].TableHeads[j];
                        SetTableTitle(ref tagtr, headstr);
                        if (wordtables[node.Attributes["w:name"].Value].TableValues[i, j] == null)
                            return;
                        string content = wordtables[node.Attributes["w:name"].Value].TableValues[i, j];
                        SetTableContent(ref tagtr, content);

                    }

                }
            }
        }
    }

    /// <summary>
    /// 根据标签水平插入一张表数据，即列名在数据上侧
    /// 表中最后一列为图片的地址
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="wordtables"></param> 
    private void SetBookMarkTablesPictureHorizontal(XmlDocument xdoc, XmlNode node, Dictionary<string, WordTable> wordtables)
    {
        if (node.NextSibling.Name.ToString() == "aml:annotation")
        {
            //查找bookmarks中是否在word标签
            if (wordtables.ContainsKey(node.Attributes["w:name"].Value))
            {
                // "w:p"节点的父节点
                XmlNode bookmrkParent = node.ParentNode;
                XmlNode bookmrkParentParent = node.ParentNode.ParentNode;
                XmlElement tagtable;
                tagtable = xdoc.CreateElement("w:tbl", nsmgr.LookupNamespace("w"));
                bookmrkParentParent.InsertAfter(tagtable, bookmrkParent);

                SetImportTableBorder(ref xdoc, ref tagtable);

                XmlElement tagtr;
                tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                tagtable.AppendChild(tagtr);

                //循环输入列名，最后一行跳过，最后一行为图片的地址
                for (int i = 0; i < wordtables[node.Attributes["w:name"].Value].TableHeads.Length - 1; i++)
                {
                    string headstr = wordtables[node.Attributes["w:name"].Value].TableHeads[i];
                    SetTableTitle(ref tagtr, headstr);
                }


                for (int i = 0; i < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(0); i++)
                {
                    tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                    tagtable.AppendChild(tagtr);

                    int colLength = wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(1);

                    for (int j = 0; j < colLength - 1; j++)
                    {
                        string content = wordtables[node.Attributes["w:name"].Value].TableValues[i, j];
                        SetTableContent(ref tagtr, content);
                    }
                    tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                    tagtable.AppendChild(tagtr);
                    SetTablePicture(ref tagtr, wordtables[node.Attributes["w:name"].Value].TableValues[i, colLength - 1], (colLength - 1).ToString());
                }
            }
        }
    }

    /// <summary>
    /// 根据标签垂直插入一张表数据，即列名在数据左侧
    /// 表中最后一列为图片的地址
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="wordtables"></param>
    private void SetBookMarkTablesPictureVertical(XmlDocument xdoc, XmlNode node, Dictionary<string, WordTable> wordtables)
    {
        if (node.NextSibling.Name.ToString() == "aml:annotation")
        {
            //查找bookmarks中是否在word标签
            if (wordtables.ContainsKey(node.Attributes["w:name"].Value))
            {
                // "w:p"节点的父节点
                XmlNode bookmrkParent = node.ParentNode;
                XmlNode bookmrkParentParent = node.ParentNode.ParentNode;
                XmlElement tagtable;
                tagtable = xdoc.CreateElement("w:tbl", nsmgr.LookupNamespace("w"));
                bookmrkParentParent.InsertAfter(tagtable, bookmrkParent);

                //设置表格样式
                SetImportTableBorder(ref xdoc, ref tagtable);

                for (int i = 0; i < wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(0); i++)
                {
                    int colLength = wordtables[node.Attributes["w:name"].Value].TableValues.GetLength(1);
                    XmlElement tagtr;
                    for (int j = 0; j < colLength - 1; j++)
                    {

                        tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                        tagtable.AppendChild(tagtr);
                        string headstr = wordtables[node.Attributes["w:name"].Value].TableHeads[j];
                        SetTableTitle(ref tagtr, headstr);
                        string content = wordtables[node.Attributes["w:name"].Value].TableValues[i, j];
                        SetTableContent(ref tagtr, content);
                    }
                    tagtr = xdoc.CreateElement("w:tr", nsmgr.LookupNamespace("w"));
                    tagtable.AppendChild(tagtr);
                    SetTablePicture(ref tagtr, wordtables[node.Attributes["w:name"].Value].TableValues[i, colLength - 1]);
                }
            }
        }
    }

    /// <summary>
    /// 设置列名
    /// </summary>
    private void SetTableTitle(ref XmlElement tagtr, string headstr)
    {
        XmlElement tagtc;
        tagtc = xdoc.CreateElement("w:tc", nsmgr.LookupNamespace("w"));
        tagtr.AppendChild(tagtc);

        XmlElement tagP;
        tagP = xdoc.CreateElement("w:p", nsmgr.LookupNamespace("w"));
        tagtc.AppendChild(tagP);

        XmlElement tagRun;
        tagRun = xdoc.CreateElement("w:r", nsmgr.LookupNamespace("w"));
        tagP.AppendChild(tagRun);

        //加粗<w:rPr><w:b/></w:rPr>
        //设置字体为<w:rPr><w:rFonts w:hint="fareast"/></w:rPr>
        XmlElement tagPr;
        tagPr = xdoc.CreateElement("w:rPr", nsmgr.LookupNamespace("w"));
        tagRun.AppendChild(tagPr);

        XmlElement tagB;
        tagB = xdoc.CreateElement("w:b", nsmgr.LookupNamespace("w"));
        tagPr.AppendChild(tagB);

        XmlElement tagText;
        tagText = xdoc.CreateElement("w:t", nsmgr.LookupNamespace("w"));
        tagRun.AppendChild(tagText);
        //插入(w:t)文本作为内容，追加至文本节点
        XmlNode nodeText;
        nodeText = xdoc.CreateNode(XmlNodeType.Text, "w:t", nsmgr.LookupNamespace("w"));
        nodeText.Value = headstr;
        tagText.AppendChild(nodeText);
    }

    /// <summary>
    /// 设置表的内容
    /// </summary>
    private void SetTableContent(ref XmlElement tagtr, string content)
    {
        XmlElement tagtc;
        tagtc = xdoc.CreateElement("w:tc", nsmgr.LookupNamespace("w"));
        tagtr.AppendChild(tagtc);

        XmlElement tagP;
        tagP = xdoc.CreateElement("w:p", nsmgr.LookupNamespace("w"));
        tagtc.AppendChild(tagP);

        XmlElement tagRun;
        tagRun = xdoc.CreateElement("w:r", nsmgr.LookupNamespace("w"));
        tagP.AppendChild(tagRun);

        XmlElement tagText;
        tagText = xdoc.CreateElement("w:t", nsmgr.LookupNamespace("w"));
        tagRun.AppendChild(tagText);

        //插入(w:t)文本作为内容，追加至文本节点
        XmlNode nodeText;
        nodeText = xdoc.CreateNode(XmlNodeType.Text, "w:t", nsmgr.LookupNamespace("w"));
        nodeText.Value = content;
        tagText.AppendChild(nodeText);
    }

    /// <summary>
    /// 设置表中图片
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="Path">Path</param>
    private void SetTablePicture(ref XmlElement tagtr, string path)
    {
        path = serverPath + path.Replace("../", "\\").Replace("/", "\\");

        XmlElement tagtc;
        tagtc = xdoc.CreateElement("w:tc", nsmgr.LookupNamespace("w"));
        tagtr.AppendChild(tagtc);


        XmlElement tagP;
        tagP = xdoc.CreateElement("w:p", nsmgr.LookupNamespace("w"));
        tagtc.AppendChild(tagP);

        XmlElement tagRun;
        tagRun = xdoc.CreateElement("w:r", nsmgr.LookupNamespace("w"));
        tagP.AppendChild(tagRun);

        XmlElement tagText;
        tagText = xdoc.CreateElement("w:t", nsmgr.LookupNamespace("w"));
        tagRun.AppendChild(tagText);
        XmlElement tagPic;

        if (File.Exists(path))
        {
            Bitmap bitmap = new Bitmap(path);

            tagPic = xdoc.CreateElement("w:pict", nsmgr.LookupNamespace("w"));
            tagRun.AppendChild(tagPic);

            XmlElement tagbindData;
            tagbindData = xdoc.CreateElement("w:binData", nsmgr.LookupNamespace("w"));
            tagPic.AppendChild(tagbindData);

            XmlAttribute nodeAttr;
            nodeAttr = xdoc.CreateAttribute("w:name", nsmgr.LookupNamespace("w"));
            nodeAttr.Value = "wordml://" + Path.GetFileName(path);
            tagbindData.Attributes.Append(nodeAttr);

            //xml:space="preserve"
            nodeAttr = xdoc.CreateAttribute("xml:space");
            nodeAttr.Value = "preserve";
            tagbindData.Attributes.Append(nodeAttr);

            XmlNode nodePicValue;
            nodePicValue = xdoc.CreateNode(XmlNodeType.Text, "w:binData", nsmgr.LookupNamespace("w"));
            nodePicValue.Value = ImgToBase64String(path);
            tagbindData.AppendChild(nodePicValue);

            XmlElement tagShape;
            tagShape = xdoc.CreateElement("v:shape", nsmgr.LookupNamespace("v"));
            tagPic.AppendChild(tagShape);

            XmlAttribute tagStyle;
            tagStyle = xdoc.CreateAttribute("style");
            tagStyle.Value = "width:" + WordWidth + "pt;height:" + WordHeight + "pt;";
            tagShape.Attributes.Append(tagStyle);


            XmlElement tagimagedata;
            tagimagedata = xdoc.CreateElement("v:imagedata", nsmgr.LookupNamespace("v"));
            tagShape.AppendChild(tagimagedata);

            nodeAttr = xdoc.CreateAttribute("src");
            nodeAttr.Value = "wordml://" + Path.GetFileName(path);
            tagimagedata.Attributes.Append(nodeAttr);
        }

    }

    /// <summary>
    /// 设置表中图片
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="Path">Path</param>
    /// <param name="colNum">合并的列数</param>
    private void SetTablePicture(ref XmlElement tagtr, string path, string colNum)
    {
        path = serverPath + path.Replace("../", "\\").Replace("/", "\\");


        XmlElement tagtc;
        tagtc = xdoc.CreateElement("w:tc", nsmgr.LookupNamespace("w"));
        tagtr.AppendChild(tagtc);

        if (colNum != string.Empty)
        {
            XmlElement tagtcPr;
            tagtcPr = xdoc.CreateElement("w:tcPr", nsmgr.LookupNamespace("w"));
            tagtc.AppendChild(tagtcPr);

            XmlElement tagtcW;
            tagtcW = xdoc.CreateElement("w:tcW", nsmgr.LookupNamespace("w"));
            tagtcPr.AppendChild(tagtcW);

            XmlAttribute nodew;
            nodew = xdoc.CreateAttribute("w:w", nsmgr.LookupNamespace("w"));
            nodew.Value = "0";
            tagtcW.Attributes.Append(nodew);

            XmlAttribute nodetype;
            nodetype = xdoc.CreateAttribute("w:type", nsmgr.LookupNamespace("w"));
            nodetype.Value = "auto";
            tagtcW.Attributes.Append(nodetype);

            XmlElement taggridSpan;
            taggridSpan = xdoc.CreateElement("w:gridSpan", nsmgr.LookupNamespace("w"));
            tagtcPr.AppendChild(taggridSpan);

            XmlAttribute nodegridSpan;
            nodegridSpan = xdoc.CreateAttribute("w:val", nsmgr.LookupNamespace("w"));
            nodegridSpan.Value = colNum;
            taggridSpan.Attributes.Append(nodegridSpan);
        }

        XmlElement tagP;
        tagP = xdoc.CreateElement("w:p", nsmgr.LookupNamespace("w"));
        tagtc.AppendChild(tagP);

        XmlElement tagRun;
        tagRun = xdoc.CreateElement("w:r", nsmgr.LookupNamespace("w"));
        tagP.AppendChild(tagRun);

        XmlElement tagText;
        tagText = xdoc.CreateElement("w:t", nsmgr.LookupNamespace("w"));
        tagRun.AppendChild(tagText);
        if (File.Exists(path))
        {
            Bitmap bitmap = new Bitmap(path);
            XmlElement tagPic;
            tagPic = xdoc.CreateElement("w:pict", nsmgr.LookupNamespace("w"));
            tagRun.AppendChild(tagPic);

            XmlElement tagbindData;
            tagbindData = xdoc.CreateElement("w:binData", nsmgr.LookupNamespace("w"));
            tagPic.AppendChild(tagbindData);

            XmlAttribute nodeAttr;
            nodeAttr = xdoc.CreateAttribute("w:name", nsmgr.LookupNamespace("w"));
            nodeAttr.Value = "wordml://" + Path.GetFileName(path);
            tagbindData.Attributes.Append(nodeAttr);

            //xml:space="preserve"
            nodeAttr = xdoc.CreateAttribute("xml:space");
            nodeAttr.Value = "preserve";
            tagbindData.Attributes.Append(nodeAttr);

            XmlNode nodePicValue;
            nodePicValue = xdoc.CreateNode(XmlNodeType.Text, "w:binData", nsmgr.LookupNamespace("w"));
            nodePicValue.Value = ImgToBase64String(path);
            tagbindData.AppendChild(nodePicValue);

            XmlElement tagShape;
            tagShape = xdoc.CreateElement("v:shape", nsmgr.LookupNamespace("v"));
            tagPic.AppendChild(tagShape);

            XmlAttribute tagStyle;
            tagStyle = xdoc.CreateAttribute("style");
            tagStyle.Value = "width:" + WordWidth + "pt;height:" + WordHeight + "pt;";
            tagShape.Attributes.Append(tagStyle);


            XmlElement tagimagedata;
            tagimagedata = xdoc.CreateElement("v:imagedata", nsmgr.LookupNamespace("v"));
            tagShape.AppendChild(tagimagedata);

            nodeAttr = xdoc.CreateAttribute("src");
            nodeAttr.Value = "wordml://" + Path.GetFileName(path);
            tagimagedata.Attributes.Append(nodeAttr);
        }

    }

    /// <summary>
    /// 设置导出表的边框样式
    /// </summary>
    /// <param name="xdoc"></param>
    private void SetImportTableBorder(ref XmlDocument xdoc, ref XmlElement tagtable)
    {

        XmlElement tagborder;
        tagborder = xdoc.CreateElement("w:tblBorders", nsmgr.LookupNamespace("w"));
        tagtable.AppendChild(tagborder);

        XmlElement tagtop;
        tagtop = xdoc.CreateElement("w:top", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(tagtop);

        XmlAttribute borderValAtrr;
        borderValAtrr = xdoc.CreateAttribute("w:val", nsmgr.LookupNamespace("w"));
        borderValAtrr.Value = "single";
        tagtop.Attributes.Append(borderValAtrr);

        XmlAttribute borderSzAtrr;
        borderSzAtrr = xdoc.CreateAttribute("w:sz", nsmgr.LookupNamespace("w"));
        borderSzAtrr.Value = "4";
        tagtop.Attributes.Append(borderSzAtrr);

        XmlAttribute borderwidthAtrr;
        borderwidthAtrr = xdoc.CreateAttribute("wx:bdrwidth", nsmgr.LookupNamespace("wx"));
        borderwidthAtrr.Value = "10";
        tagtop.Attributes.Append(borderwidthAtrr);

        XmlAttribute borderspaceAtrr;
        borderspaceAtrr = xdoc.CreateAttribute("w:space", nsmgr.LookupNamespace("w"));
        borderspaceAtrr.Value = "0";
        tagtop.Attributes.Append(borderspaceAtrr);

        XmlAttribute bordercolorAtrr;
        bordercolorAtrr = xdoc.CreateAttribute("w:color", nsmgr.LookupNamespace("w"));
        bordercolorAtrr.Value = "auto";
        tagtop.Attributes.Append(bordercolorAtrr);

        XmlElement tagleft;
        tagleft = xdoc.CreateElement("w:left", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(tagleft);
        tagleft.Attributes.Append(borderValAtrr.Clone() as XmlAttribute);
        tagleft.Attributes.Append(borderSzAtrr.Clone() as XmlAttribute);
        tagleft.Attributes.Append(borderwidthAtrr.Clone() as XmlAttribute);
        tagleft.Attributes.Append(borderspaceAtrr.Clone() as XmlAttribute);
        tagleft.Attributes.Append(bordercolorAtrr.Clone() as XmlAttribute);

        XmlElement tagbottom;
        tagbottom = xdoc.CreateElement("w:bottom", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(tagbottom);
        tagbottom.Attributes.Append(borderValAtrr.Clone() as XmlAttribute);
        tagbottom.Attributes.Append(borderSzAtrr.Clone() as XmlAttribute);
        tagbottom.Attributes.Append(borderwidthAtrr.Clone() as XmlAttribute);
        tagbottom.Attributes.Append(borderspaceAtrr.Clone() as XmlAttribute);
        tagbottom.Attributes.Append(bordercolorAtrr.Clone() as XmlAttribute);

        XmlElement tagright;
        tagright = xdoc.CreateElement("w:right", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(tagright);
        tagright.Attributes.Append(borderValAtrr.Clone() as XmlAttribute);
        tagright.Attributes.Append(borderSzAtrr.Clone() as XmlAttribute);
        tagright.Attributes.Append(borderwidthAtrr.Clone() as XmlAttribute);
        tagright.Attributes.Append(borderspaceAtrr.Clone() as XmlAttribute);
        tagright.Attributes.Append(bordercolorAtrr.Clone() as XmlAttribute);

        XmlElement taginsideH;
        taginsideH = xdoc.CreateElement("w:insideH", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(taginsideH);
        taginsideH.Attributes.Append(borderValAtrr.Clone() as XmlAttribute);
        taginsideH.Attributes.Append(borderSzAtrr.Clone() as XmlAttribute);
        taginsideH.Attributes.Append(borderwidthAtrr.Clone() as XmlAttribute);
        taginsideH.Attributes.Append(borderspaceAtrr.Clone() as XmlAttribute);
        taginsideH.Attributes.Append(bordercolorAtrr.Clone() as XmlAttribute);

        XmlElement taginsideV;
        taginsideV = xdoc.CreateElement("w:insideV", nsmgr.LookupNamespace("w"));
        tagborder.AppendChild(taginsideV);
        taginsideV.Attributes.Append(borderValAtrr.Clone() as XmlAttribute);
        taginsideV.Attributes.Append(borderSzAtrr.Clone() as XmlAttribute);
        taginsideV.Attributes.Append(borderwidthAtrr.Clone() as XmlAttribute);
        taginsideV.Attributes.Append(borderspaceAtrr.Clone() as XmlAttribute);
        taginsideV.Attributes.Append(bordercolorAtrr.Clone() as XmlAttribute);

    }

    /// <summary>
    /// 根据标签插入一张图片
    /// </summary>
    /// <param name="xdoc"></param>
    /// <param name="node"></param>
    /// <param name="picpaths"></param>
    private void SetBookMarkPics(XmlDocument xdoc, XmlNode node, Dictionary<string, WordPic> picpaths)
    {
        if (node.NextSibling.Name.ToString() == "aml:annotation")//w:bookmarkEnd
        {
            //查找bookmarks中是否在word标签
            if (picpaths.ContainsKey(node.Attributes["w:name"].Value))
            {
                // "w:p"节点的父节点
                XmlNode bookmrkParent = node.ParentNode;
                XmlNode bookmrkParentParent = node.ParentNode.ParentNode;

                XmlElement tagPic;
                tagPic = xdoc.CreateElement("w:pict", nsmgr.LookupNamespace("w"));
                bookmrkParentParent.InsertAfter(tagPic, bookmrkParent);

                XmlElement tagbindData;
                tagbindData = xdoc.CreateElement("w:binData", nsmgr.LookupNamespace("w"));
                tagPic.AppendChild(tagbindData);

                XmlAttribute nodeAttr;
                nodeAttr = xdoc.CreateAttribute("w:name", nsmgr.LookupNamespace("w"));
                nodeAttr.Value = "wordml://" + Path.GetFileName(picpaths[node.Attributes["w:name"].Value].PicPath);
                tagbindData.Attributes.Append(nodeAttr);

                //xml:space="preserve"
                nodeAttr = xdoc.CreateAttribute("xml:space");
                nodeAttr.Value = "preserve";
                tagbindData.Attributes.Append(nodeAttr);


                XmlNode nodePicValue;
                nodePicValue = xdoc.CreateNode(XmlNodeType.Text, "w:binData", nsmgr.LookupNamespace("w"));
                nodePicValue.Value = ImgToBase64String(picpaths[node.Attributes["w:name"].Value].PicPath);
                tagbindData.AppendChild(nodePicValue);

                XmlElement tagShape;
                tagShape = xdoc.CreateElement("v:shape", nsmgr.LookupNamespace("v"));
                tagPic.AppendChild(tagShape);


                XmlAttribute tagStyle;
                tagStyle = xdoc.CreateAttribute("style");
                tagStyle.Value = "width:" + picpaths[node.Attributes["w:name"].Value].Width + "pt;height:" + picpaths[node.Attributes["w:name"].Value].Height + "pt;";
                tagShape.Attributes.Append(tagStyle);


                XmlElement tagimagedata;
                tagimagedata = xdoc.CreateElement("v:imagedata", nsmgr.LookupNamespace("v"));
                tagShape.AppendChild(tagimagedata);

                nodeAttr = xdoc.CreateAttribute("src");
                nodeAttr.Value = "wordml://" + Path.GetFileName(picpaths[node.Attributes["w:name"].Value].PicPath);
                tagimagedata.Attributes.Append(nodeAttr);

            }
        }
    }

    private string ImgToBase64String(string Imagefilename)
    {
        System.IO.MemoryStream m = new System.IO.MemoryStream();
        try
        {
            System.Drawing.Bitmap bp = new System.Drawing.Bitmap(Imagefilename);
            bp.Save(m, System.Drawing.Imaging.ImageFormat.Jpeg);
            byte[] b = m.GetBuffer();
            return Convert.ToBase64String(b);
        }
        finally
        {
            m.Close();
        }
    }

    #endregion

    #region

    //WordTable对象
    public class WordTable
    {

        private string[] _tableHeads;

        public string[] TableHeads
        {
            get { return _tableHeads; }
            set { _tableHeads = value; }
        }

        private string[,] _tableValues;

        public string[,] TableValues
        {
            get { return _tableValues; }
            set { _tableValues = value; }
        }

        public static WordTable GetWordTabelFromDataTable(System.Data.DataTable table)
        {

            WordTable wordtable = new WordTable();
            if (table != null)
            {
                string[] tableheads = new string[table.Columns.Count];
                int i = 0;
                foreach (DataColumn dc in table.Columns)
                {
                    tableheads[i] = dc.ColumnName;
                    i++;
                }
                wordtable.TableHeads = tableheads;

                i = 0;
                string[,] tablevalues = new string[table.Rows.Count, table.Columns.Count];
                for (int j = 0; j < table.Rows.Count; j++)
                {
                    for (int k = 0; k < table.Columns.Count; k++)
                    {
                        tablevalues[j, k] = table.Rows[j][k].ToString();
                    }
                }
                wordtable.TableValues = tablevalues;
            }
            return wordtable;
        }
    }

    //word中插入的图片对象
    public class WordPic
    {
        private int _height;

        public int Height
        {
            get { return _height; }
            set { _height = value; }
        }

        private int _width;

        public int Width
        {
            get { return _width; }
            set { _width = value; }
        }

        private string _picpath;

        public string PicPath
        {
            get { return _picpath; }
            set { _picpath = value; }
        }
    }

    #endregion

}

P。S 对于使用SetNodeTextDataSet和SetNodeTextDataTable导出数据时，要注意模板标签的命名方式，是以“表明_字段名”来命名。⊙﹏⊙b汗 原来忘记说了。