基于MVC框架Aspose.Words打印到Word中写法

最新推荐文章于 2024-07-24 15:17:56 发布
置顶 最新推荐文章于 2024-07-24 15:17:56 发布
阅读量747 收藏 1
点赞数
分类专栏： ASp.net Aspose.Words 文章标签： MVC Aspose.Words Aspose Word 打印 
控件bin文件下载地址：https://download.csdn.net/download/u012949335/10610726


//cshtml写法
@{
    ViewBag.Title = "xs";
}

<script type="text/javascript">
   
    function dy() {
        var form = $("<form action='dy'></form>");
                var param = $("<input type='hidden' value='" + ids + "' name=\"ids\"/>");
                form.append(param);
                $("body").append(form);
                form.submit();
    }
</script>
<div id="div">
    <form id="form" name="form" style="padding:5px; margin:0px;">
        <table width="100%">
            <tr>
                <td align="right">

                    <button type="button" class="but-primary" onclick="dy()"> 打印</button>
                </td>
            </tr>
        </table>
    </form>
</div>



//控制器写法
public ActionResult dy(string ids)
        {
            string mbpath = Server.MapPath(".../Word/doc.doc");
            List<PrintData> listp = data(ids);
            PrintClass pc = new PrintClass();
            pc.Path = mbpath;
            var doc = pc.Print_InfoLists(listp);
            var ms = pc.GetWordStream(doc, false);
            return File(ms.ToArray(), "application/octet-stream", "sddq.doc");
        }
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.IO;
using Aspose.Words;
using Aspose.Words.Saving;
using System.Data;
using Aspose.Words.Drawing;
using System.Text.RegularExpressions;
using System.Drawing;
using Aspose.Words.Tables;

namespace YidiTutor.Common
{
    public class PrintClass
    {
        public string PrintType = "word";//打印类型
        public string Path = string.Empty;
        public string filename = string.Empty;
        public string WordTabChar = "$";

        public PrintClass()
        { }

        public PrintClass(string printtype)
        {
            PrintType = printtype;
        }

        public MemoryStream GetWordStream(Document doc)
        {
            return GetWordStream(doc, true);
        }

        public MemoryStream GetWordStream(Document doc, bool noedit)
        {
            MemoryStream docStream = new MemoryStream();
            if (noedit)
                doc.Protect(ProtectionType.AllowOnlyFormFields);//只读无法编辑，因为没有密码确认 
            doc.Save(docStream, SaveFormat.Doc);
            return docStream;
        }

        public Document Print_InfoLists(List<PrintData> pageData)
        {
            int p = 0;
            Document maindoc = new Document();
            foreach (var item in pageData)
            {
                Dictionary<string, string> dic = item.dict;
                Document newdoc = new Document(Path);
                DocumentBuilder build = new DocumentBuilder(newdoc);
                List<DataTable> dtinfos = item.dtinfos;
                for (int i = 0; i < dtinfos.Count; i++)
                {
                    DataTable dtinfo = dtinfos[i];
                    if (dtinfo != null)
                    {
                        for (int n = 0; n < dtinfo.Columns.Count; n++)
                        {
                            string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                            try
                            {
                                string fieldvalue = dtinfo.Rows[0][fieldname].ToString();
                                if (build.MoveToBookmark(fieldname))
                                {
                                    build.InsertHtml(fieldvalue);
                                }
                                else
                                {
                                    if (fieldvalue.Contains("\r\n"))
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, "#" + fieldname.ToUpper() + "#", false, false);
                                        Regex reg = new Regex("#" + fieldname.ToUpper() + "#");
                                        newdoc.Range.Replace(reg, new ReplaceText(fieldvalue), true);
                                    }
                                    else if (fieldvalue.Contains("<p>"))
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, "#" + fieldname.ToUpper() + "#", false, false);
                                        Regex reg = new Regex("#" + fieldname.ToUpper() + "#");
                                        newdoc.Range.Replace(reg, new ReplaceHtml(fieldvalue), true);
                                    }
                                    else
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, fieldvalue, false, false);
                                    }
                                }
                            }
                            catch { }
                        }
                    }
                }
                Dictionary<string, string> dict = item.dict;
                if (dict != null)
                {
                    foreach (var key in dict.Keys)
                    {
                        try
                        {
                            if (build.MoveToBookmark(key))
                            {
                                build.InsertHtml(dict[key]);
                            }
                            else
                            {
                                newdoc.Range.Replace(WordTabChar + key + WordTabChar, dict[key], false, false);
                            }
                        }
                        catch { }
                    }
                }
                List<PositionProChildren> listpos = new List<PositionProChildren>();
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                List<DataTable> dtlist = item.dtlist;
                int tablecount = newdoc.GetChildNodes(NodeType.Table, true).Count;
                int dtlistcount = 0;
                for (int i = 0; i < tablecount; i++)
                {
                    Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, i, true);
                    for (int r = 0; r < dtdoc.Rows.Count; r++)
                    {
                        for (int c = 0; c < dtdoc.Rows[r].Cells.Count; c++)
                        {
                            if (dtdoc.Rows[r].Cells[c].Range.Text.ToLower().Contains("#start#"))
                            {
                                dtlistcount++;
                                PositionProChildren pos = new PositionProChildren();
                                pos.tableindex = i;
                                pos.row_start = r;
                                pos.cell_start = c;
                                pos.row_end = r;
                                pos.cell_end = c;
                                listpos.Add(pos);
                                dtdoc.Rows[r].Cells[c].Range.Replace("#START#", "", false, false);
                            }
                            if (dtdoc.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                            {
                                PositionProChildren pos = listpos.Last<PositionProChildren>();
                                pos.row_end = r;
                                pos.cell_end = c;
                                dtdoc.Rows[r].Cells[c].Range.Replace("#END#", "", false, false);
                            }
                        }
                    }
                }
                if (dtlist != null && dtlistcount.Equals(dtlist.Count))
                {
                    for (int i = 0; i < dtlist.Count; i++)
                    {
                        PositionProChildren pos = new PositionProChildren();
                        if (listpos.Count > i)
                        {
                            pos = listpos[i];
                        }
                        Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, pos.tableindex, true);//定位第一个table
                        DataTable dt = dtlist[i];
                        List<string> celltabs = new List<string>();
                        for (int t = pos.cell_start; t < dtdoc.Rows[pos.row_start].Cells.Count; t++)
                        {
                            string colname = dtdoc.Rows[pos.row_start].Cells[t].Range.Text.Replace(WordTabChar, "").Replace("\a", "");
                            celltabs.Add(colname);
                            dtdoc.Rows[pos.row_start].Range.Replace(WordTabChar + colname + WordTabChar, "", false, false);
                        }
                        if (dt.Rows.Count > pos.rownum)
                        {
                            int addrow = dt.Rows.Count - pos.rownum;
                            for (int a = 0; a < addrow; a++)
                            {
                                Aspose.Words.Node newrow = dtdoc.Rows[pos.row_start].Clone(true);
                                dtdoc.Rows.Insert(pos.row_start + 1, newrow);
                                if (i < listpos.Count - 1)
                                {
                                    for (int l = i + 1; l < listpos.Count; l++)
                                    {
                                        PositionProChildren poscur = listpos[l - 1];
                                        PositionProChildren posnext = listpos[l];
                                        if (posnext.tableindex.Equals(poscur.tableindex))
                                        {
                                            posnext.row_start += 1;
                                            posnext.row_end += 1;
                                        }
                                        else
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                        for (int m = 0; m < dt.Rows.Count; m++)
                        {
                            for (int n = 0; n < celltabs.Count; n++)
                            {
                                try
                                {
                                    builder.MoveToCell(pos.tableindex, pos.row_start + m, pos.cell_start + n, 0);
                                    builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                                }
                                catch { }
                            }
                        }
                    }
                }
                if (!p.Equals(0))
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
                else
                {
                    maindoc = newdoc;
                }
                p++;
            }
            return maindoc;
        }
        /// <summary>
        /// 不受word分节符影响打印
        /// </summary>
        /// <param name="datalist">List<PrintData></param>
        /// <returns>Document</returns>
        public Document PrintDocumentAllWord(List<PrintData> datalist)
        {
            int p = 0;
            Document maindoc = new Document();
            foreach (var page in datalist)
            {
                Document newdoc = new Document(Path);
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                List<DataTable> dtinfos = page.dtinfos;
                if (dtinfos != null)
                {
                    for (int i = 0; i < dtinfos.Count; i++)
                    {
                        DataTable dtinfo = dtinfos[i];
                        if (dtinfo != null)
                        {
                            for (int n = 0; n < dtinfo.Columns.Count; n++)
                            {
                                string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                                try
                                {
                                    string fieldvalue = dtinfo.Rows[0][fieldname].ToString();
                                    if (fieldvalue.Contains("\r\n"))
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, "#" + fieldname.ToUpper() + "#", false, false);
                                        Regex reg = new Regex("#" + fieldname.ToUpper() + "#");
                                        newdoc.Range.Replace(reg, new ReplaceText(fieldvalue), true);
                                    }
                                    else if (fieldvalue.Contains("<p>"))
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, "#" + fieldname.ToUpper() + "#", false, false);
                                        Regex reg = new Regex("#" + fieldname.ToUpper() + "#");
                                        newdoc.Range.Replace(reg, new ReplaceHtml(fieldvalue), true);
                                    }
                                    else
                                    {
                                        newdoc.Range.Replace(WordTabChar + fieldname + WordTabChar, fieldvalue, false, false);
                                    }
                                }
                                catch { }
                            }
                        }
                    }
                }
                Dictionary<string, string> dict = page.dict;
                if (dict != null)
                {
                    foreach (var key in dict.Keys)
                    {
                        try
                        {
                            newdoc.Range.Replace(WordTabChar + key + WordTabChar, dict[key], false, false);
                        }
                        catch { }
                    }
                }
                List<PositionProChildren> listpos = new List<PositionProChildren>();
                List<DataTable> dtlist = page.dtlist;
                int section = newdoc.GetChildNodes(NodeType.Section, true).Count;
                int dataindex = 0;
                for (int kk = 0; kk < section; kk++)
                {
                    Aspose.Words.Section dtsection = (Aspose.Words.Section)newdoc.GetChild(NodeType.Section, kk, true);
                    int num = dtsection.Body.Tables.Count;
                    for (int mm = 0; mm < num; mm++)
                    {
                        Aspose.Words.Tables.Table dtdoc1 = dtsection.Body.Tables[mm];

                        for (int r = 0; r < dtdoc1.Rows.Count; r++)
                        {
                            for (int c = 0; c < dtdoc1.Rows[r].Cells.Count; c++)
                            {
                                if (dtdoc1.Rows[r].Cells[c].Range.Text.ToLower().Contains("#start#"))
                                {
                                    PositionProChildren pos = new PositionProChildren();
                                    pos.tableindex = mm;
                                    pos.row_start = r;
                                    pos.cell_start = c;
                                    pos.row_end = r;
                                    pos.cell_end = c;
                                    listpos.Add(pos);
                                    dtdoc1.Rows[r].Cells[c].Range.Replace("#START#", "", false, false);
                                }
                                if (dtdoc1.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                                {
                                    PositionProChildren pos = listpos.Last<PositionProChildren>();
                                    pos.row_end = r;
                                    pos.cell_end = c;
                                    dtdoc1.Rows[r].Cells[c].Range.Replace("#END#", "", false, false);
                                }
                            }
                        }
                        for (int i = 0; i < listpos.Count; i++)
                        {
                            PositionProChildren pos = new PositionProChildren();
                            if (listpos.Count > i)
                            {
                                pos = listpos[i];
                            }
                            DataTable dt = dtlist[i + dataindex];

                            Aspose.Words.Tables.Table dtdoc = dtsection.Body.Tables[mm];
                            List<string> celltabs = new List<string>();
                            for (int t = pos.cell_start; t < dtdoc.Rows[pos.row_start].Cells.Count; t++)
                            {
                                string colname = dtdoc.Rows[pos.row_start].Cells[t].Range.Text.Replace(WordTabChar, "").Replace("\a", "");
                                celltabs.Add(colname);
                                dtdoc.Rows[pos.row_start].Range.Replace(WordTabChar + colname + WordTabChar, "", false, false);
                            }
                            if (dt.Rows.Count > pos.rownum)
                            {
                                int addrow = dt.Rows.Count - pos.rownum;
                                for (int a = 0; a < addrow; a++)
                                {
                                    Aspose.Words.Node newrow = dtdoc.Rows[pos.row_start + 1].Clone(true);//确认模板有第二行
                                    dtdoc.Rows.Insert(pos.row_start + 1, newrow);
                                    if (i < listpos.Count - 1)
                                    {
                                        for (int l = i + 1; l < listpos.Count; l++)
                                        {
                                            PositionProChildren poscur = listpos[l - 1];
                                            PositionProChildren posnext = listpos[l];
                                            if (posnext.tableindex.Equals(poscur.tableindex))
                                            {
                                                posnext.row_start += 1;
                                                posnext.row_end += 1;
                                            }
                                            else
                                                break;
                                        }
                                    }
                                }

                            }

                            for (int m = 0; m < dt.Rows.Count; m++)
                            {
                                for (int n = 0; n < celltabs.Count; n++)
                                {
                                    try
                                    {
                                        builder.MoveToSection(kk);
                                        builder.MoveToCell(pos.tableindex, pos.row_start + m, pos.cell_start + n, 0);
                                        builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                                    }
                                    catch { }
                                }
                            }


                        }

                        dataindex = dataindex + listpos.Count;
                        listpos.Clear();

                    }



                }
                if (!p.Equals(0))
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
                else
                {
                    maindoc = newdoc;
                }
                p++;
            }
            return maindoc;
        }

    }



    /// <summary>
    /// 替换带有\r\n格式的数据
    /// </summary>
    public class ReplaceText : IReplacingCallback
    {
        public string Text { get; set; }
        public ReplaceText(string Text)
        {
            this.Text = Text;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点        
            var node = e.MatchNode;
            Document doc = node.Document as Document;
            DocumentBuilder builder = new DocumentBuilder(doc);
            builder.MoveTo(node);
            builder.Write(Text);
            return ReplaceAction.Replace;
        }
    }


    /// <summary>
    /// 替换html格式的数据
    /// </summary>
    public class ReplaceHtml : IReplacingCallback
    {
        public string Text { get; set; }
        public ReplaceHtml(string Text)
        {
            this.Text = Text;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点        
            var node = e.MatchNode;
            Document doc = node.Document as Document;
            DocumentBuilder builder = new DocumentBuilder(doc);
            builder.MoveTo(node);
            builder.InsertHtml(Text);
            return ReplaceAction.Replace;
        }
    }

    /// <summary>
    /// 替换图片
    /// </summary>
    public class ReplaceImage : IReplacingCallback
    {
        /// <summary>
        /// 需要插入的图片路径        
        /// </summary>
        public string ImageUrl { get; set; }
        public double ImageWidth { get; set; }
        public double ImageHeight { get; set; }
        public ReplaceImage(string url)
        {
            this.ImageUrl = url;
            ImageWidth = 80;
            ImageHeight = 120;
        }
        public ReplaceAction Replacing(ReplacingArgs e)
        {
            //获取当前节点        
            if (!string.IsNullOrEmpty(ImageUrl))
            {
                var node = e.MatchNode;
                Document doc = node.Document as Document;
                DocumentBuilder builder = new DocumentBuilder(doc);
                builder.MoveTo(node);
                //builder.Write(Text);
                Aspose.Words.Drawing.Shape shape = new Aspose.Words.Drawing.Shape(doc, Aspose.Words.Drawing.ShapeType.Image);
                shape.ImageData.SetImage(ImageUrl);
                shape.Top = 0;
                shape.Width = ImageWidth;
                shape.Height = ImageHeight;
                shape.HorizontalAlignment = HorizontalAlignment.Center;
                CompositeNode node1 = shape.ParentNode;
                builder.InsertNode(shape);
            }
            return ReplaceAction.Replace;
        }
    }
    public class PositionPro
    {
        public string key { get; set; }
        public int row_start { get; set; }
        public int row_end { get; set; }
        public int cell_start { get; set; }
        public int cell_end { get; set; }
        public int rownum
        {
            get
            {
                return row_end - row_start + 1;
            }
        }
    }
    public class PositionProChildren : PositionPro
    {
        public int tableindex { get; set; }
    }
    /// <summary>
    /// 批量打印实体类
    /// </summary>
    public class PrintData
    {
        public List<DataTable> dtinfos;
        public Dictionary<string, string> dict;
        public List<DataTable> dtlist;
        public string filepath;
    }

}

筱筱脱脱
关注
专栏目录
利用Aspose.Words打印word文档
keep innocent
09-13 6133
Aspose.Words是一款先进的类库，可以直接在各个应用程序中执行各种文档处理，即使在没有Microsoft word 的情况下，仍然可以生成，更改，转换，渲染和打印word文档，并且支持DOC，PDF等其他格式。          下面就以  Aspose.Words如何实现打印word文档为例做一个小demo。 1·制作word模板       在word模板中，在需要插入的地方选
使用Aspose来打印Word
07-18
Aspose来打印word，是比较常用的方法，如果有什么问题请留言。使用的方法看主页的文章介绍。
【word转pdf】【最新版本jar24.3】【持续更新】Java使用aspose-words实现word文档转pdf
最新发布
Tm598035415的博客
07-24 899
将win机器的c:\windows\fonts目录下的全部文件拷贝到生产服务器字体安装目录下，然后执行以下命令更新字体缓存。链接：https://pan.baidu.com/s/1Iii3MCbYqR9XUXGyFE727Q?通过百度网盘分享的文件：aspose-words-24.3.jar。word中如果有jpg格式的图片，需要转换格式成 png。在resource路径下配置license.xml文件。xxxxxxxxxx = jar下载之后的目录。
Aspose.Words将Word模板打印出来
weixin_30404405的博客
09-07 218
利用Aspose.Words将制作好的模板，输出出来自己所需的文件 /// <summary> /// 打印信息和列表 /// </summary> /// <param name="dtinfo"></param> /// <param name="dtlis...
没有安装Microsoft Words的情况下读写Word文档的控件Aspose.Words​
weixin_34326558的博客
06-21 187
2019独角兽企业重金招聘Python工程师标准>>> ...
aspose.word 批量打印
04-03
aspose 组件中的 aspose.word 做word批量打印 脱离了office的相关dll
Aspose.Words_生成excel_aspose.word_生成word_aspose.words_
10-02
Aspose.Words是一款强大的文档处理库，主要用于在.NET环境中创建、操作和转换Microsoft Word文档。它提供了丰富的功能，使得开发者无需依赖Microsoft Office就可以处理Word文件，极大地提升了开发效率和应用程序的...
Aspose.Words导出到word
01-26
Aspose.Words的使用首先需要添加对应的NuGet包或者DLL引用到项目中。通过`using Aspose.Words;`引入命名空间，然后可以创建`Document`对象来加载或创建Word文档。 2. 文档加载与创建： - 加载：`Document doc = ...
解决用Aspose.Words,在word文档中创建表格的实现方法
12-31
代码如下所示： 代码如下: //Open document and create Documentbuilder Aspose.Words.Document doc = new Aspose.Words.Document(“demo.doc”); DocumentBuilder builder = new DocumentBuilder(doc); //Set ...
aspose.words.dll资源下载
09-15
适用于.netcore2、3.1。直接引用即可，如果出现缺失SkiaSharp.dll情况，可以引用资源里的SkiaSharp.dll，或者NuGet里面搜索SkiaSharp找适合.netcore版本的包安装就没问题了。
Word文档加水印(利用Aspose.Words.dll)
09-13
本项目聚焦于使用C#编程语言，在WPF（Windows Presentation Foundation）环境中，结合Aspose.Words.dll库来实现Word文档的水印添加以及接受修订功能。下面将详细介绍这个过程及其相关知识点。 首先，Aspose.Words....
aspose模板导出word及pdf打印
10-15
aspose模板导出word及pdf打印.
Aspose打印相关的bin文件(更新)
04-06
Aspose
用Aspose来打印Word方法类
u012949335的专栏
07-18 5710
详细链接：https://shop499704308.taobao.com/?spm=a1z38n.10677092.card.11.594c1debsAGeak 使用Aspose来打印word是常用的一种方法，循环打印，多个列表打印，图片打印，数据库SQL查询语句select xx1,xx2,xx3 from 表名称，Word里面对应的就写$XX1$,$XX2$,$XX3$，当然也可以根据自...
asp.net 网页中嵌入word的一个实例
aonordcv69558的博客
12-25 149
最近在做一套oa系统的财务模块，由于需要经常处理word,excel等office软件，又懒得去画界面，于是考虑把这些表格做成模板放到页面中去。做成的一个实例参考：/Files/Hard/PowerOA.rar。 需要说明的是：因为要调用iweboffice2006，所以项目不能用cookie做验证。项目使用vs2005和sql server2005.并且只做了页面...
C# Aspose.Words调取打印机列表打印相关文件
weixin_40029679的博客
11-08 474
aspose word 打印的相关方法，参数一目了然。
基于FreeMarker+aspose的Word模板制作及打印
weixin_42653892的博客
11-09 2778
基于FreeMarker+aspose的Word模板制作及打印，简单介绍了： 普通文本渲染，普通list数据渲染，横向list数据渲染， 图片插入，图表制作，循环复制图表及相关工具类使用和html渲染/图表/三测单结果示例 3.7 freemaker相关语法说明
Aspose转Doc和打印
zhx2011341124的博客
11-28 477
把需要的资料写入文档里面，再转成可用的DOCX文件，供打印使用， 破解版Aspose：链接：https://pan.baidu.com/s/1D7tY5_XiHtYsCUR7nibEjw  提取码：54g0  Aspose.Words.Document doc = new Aspose.Words.Document("模板.docx"); var dic = new Dict...
用Aspose.Words将表单信息写入到word模板中
ws_hgo的专栏
06-11 5092
用Aspose.Words将表单信息写入到word模板中
aspose.words读取word
09-12
您好！要使用Aspose.Words读取Word文档，您可以按照以下步骤进行操作： 1. 确保您已经安装了Aspose.Words库。您可以从Aspose官网下载并安装该库。 2. 在您的项目中引用Aspose.Words库。这可以通过在您的项目中添加对Aspose.Words的引用来实现。具体操作取决于您使用的开发环境和编程语言。 3. 创建一个新的Aspose.Words.Document对象。您可以使用该对象来加载和操作Word文档。 ```csharp Document doc = new Document("input.docx"); // 根据文档路径加载文档 ``` 4. 使用Document对象的方法和属性来读取文档内容。例如，您可以使用以下代码获取文档中的所有段落： ```csharp foreach (Paragraph paragraph in doc.GetChildNodes(NodeType.Paragraph, true)) { Console.WriteLine(paragraph.GetText()); } ``` 或者，您可以使用以下代码获取特定段落的文本： ```csharp Paragraph paragraph = (Paragraph)doc.GetChild(NodeType.Paragraph, 0, true); Console.WriteLine(paragraph.GetText()); ``` 这只是Aspose.Words库中读取Word文档的基本示例。您可以根据自己的需求进行更多高级操作，例如读取表格、图片等。具体的操作方法可以参考Aspose.Words官方文档或示例代码。 希望对您有所帮助！如果您还有其他问题，请随时提问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值