用Aspose来打印Word方法类

最新推荐文章于 2024-08-12 11:44:21 发布
置顶 最新推荐文章于 2024-08-12 11:44:21 发布
阅读量5.7k 收藏 3
点赞数
文章标签： Word打印 打印 asp.net c# Aspose

详细链接：https://shop499704308.taobao.com/?spm=a1z38n.10677092.card.11.594c1debsAGeak

使用Aspose来打印word是常用的一种方法，循环打印，多个列表打印，图片打印，数据库SQL查询语句select xx1,xx2,xx3 from 表名称，Word里面对应的就写$XX1$,$XX2$,$XX3$，当然也可以根据自己需要自定义，用到的Aspose去主页下载，当然也可以点击http://download.csdn.net/detail/u012949335/9579250下载。

</pre><pre name="code" class="csharp">
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using Aspose.Words;
using System.Configuration;
using System.Data.SqlClient;
using System.Reflection;
using Aspose.Words.Drawing;
using System.Text.RegularExpressions;
using System.IO;
using Aspose.Words.Saving;
using Aspose.Words.Tables;
using System.Text;
using System.Drawing.Printing;
using System.Collections;


namespace Gmis.WebControl
{
    public class PrintClass
    {
        public string path = string.Empty;
        public string filename = "打印";
        public string WordTabChar = "$";
        public string title = string.Empty;
        public static string Dotype = "word";

        /// <summary>
        /// 保存文档
        /// </summary>
        /// <param name="doc"></param>
        private void SaveDocument(Document doc)
        {
         
            if (Dotype.Equals("word"))
            {
                SaveOptions saveop = SaveOptions.CreateSaveOptions(filename + ".doc");
                doc.Save(HttpContext.Current.Response, filename + ".doc", ContentDisposition.Attachment, saveop);
            }
           
        }

       

        /// <summary>
        /// 打印信息和列表
        /// </summary>
        /// <param name="dtinfo"></param>
        /// <param name="dtlist"></param>
        public void Print_InfoList(DataTable dtinfo, DataTable dtlist)
        {
            Document maindoc = new Document();
            DocumentBuilder builder = null;
            Document newdoc = new Document(path);
            builder = new DocumentBuilder(newdoc);

          
            newdoc.Range.Replace(WordTabChar + "title" + WordTabChar, title, false, false);// 清掉标示
            for (int n = 0; n < dtinfo.Columns.Count; n++)
            {
                string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                try
                {
                    newdoc.Range.Replace(WordTabChar + fieldname.ToLower() + WordTabChar, dtinfo.Rows[0][fieldname].ToString(), false, false);
                }
                catch { }
            }

            Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, 0, true);//定位第一个table
            int listrow = 0, listcell = 0;
            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(WordTabChar + "list" + WordTabChar))
                    {
                        listrow = r;
                        listcell = c;
                    }

                }
                if (listrow > 0)
                { break; }
            }

            newdoc.Range.Replace(WordTabChar + "list" + WordTabChar, "", false, false);
            List<string> celltabs = new List<string>();

            for (int t = listcell; t < dtdoc.Rows[listrow].Cells.Count; t++)
            {
                string colname = dtdoc.Rows[listrow].Cells[t].Range.Text.Replace(WordTabChar, "").Replace("\a", "");
                celltabs.Add(colname);
                newdoc.Range.Replace(WordTabChar + colname + WordTabChar, "", false, false);
            }
          

            //插入需要补充的行
            int ynum = dtdoc.Rows.Count;
            for (int k = 0; k < dtlist.Rows.Count - (ynum - listrow); k++)
            {
                Aspose.Words.Node newrow1 = dtdoc.Rows[listrow + k + 1].Clone(true);
                dtdoc.Rows.Insert(listrow + k, newrow1);
            }

            for (int m = 0; m < dtlist.Rows.Count; m++)
            {

                for (int n = 0; n < celltabs.Count; n++)
                {
                    try
                    {
                        builder.MoveToCell(0, listrow + m, listcell + n, 0);
                        builder.Write(dtlist.Rows[m][celltabs[n].ToString()].ToString());
                    }
                    catch
                    {
                        //builder.MoveToCell(0, listrow + m, listcell + n, 0);
                        //builder.Write(dtlist.Rows[m][celltabs[n].ToString()].ToString());
                    }
                }
            }

            maindoc = newdoc;
            maindoc.Protect(ProtectionType.AllowOnlyFormFields);//只读无法编辑，因为没有密码确认         
            this.SaveDocument(maindoc);
        }

        /// <summary>
        /// 打印信息和列表
        /// </summary>
        /// <param name="dtinfo"></param>
        /// <param name="dtlist"></param>
        public void Print_InfoList(DataTable dtinfo, Dictionary<string, string> dict, DataTable dtlist, int tableindex)
        {
            //Print_InfoList(dtinfo, dict, dtlist, false);
            Document maindoc = new Document();
            Document newdoc = new Document(path);
            DocumentBuilder builder = new DocumentBuilder(newdoc);
            newdoc.Range.Replace(WordTabChar + "title" + WordTabChar, title, false, false);
            if (dtinfo != null)
            {
                for (int n = 0; n < dtinfo.Columns.Count; n++)
                {
                    string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                    try
                    {
                        newdoc.Range.Replace(WordTabChar + fieldname.ToLower() + WordTabChar, dtinfo.Rows[0][fieldname].ToString(), false, false);
                    }
                    catch { }
                }
            }
            if (dict != null)
            {
                foreach (string k in dict.Keys)
                {
                    newdoc.Range.Replace(WordTabChar + k.ToLower() + WordTabChar, dict[k].ToString(), false, false);
                }
            }
            Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, tableindex, true);//定位第一个table
            PositionPro pos = new PositionPro();
            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#"))
                    {

                        pos.row_start = r;
                        pos.cell_start = c;
                        pos.row_end = r;
                        pos.cell_end = c;
                    }
                    if (dtdoc.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                    {
                        pos.row_end = r;
                        pos.cell_end = c;
                    }
                }

            }
            newdoc.Range.Replace("#START#", "", false, false);
            newdoc.Range.Replace("#END#", "", false, false);

            DataTable dt = dtlist;
            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].Cells[t].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);
                }
            }
            for (int m = 0; m < dt.Rows.Count; m++)
            {
                for (int n = 0; n < celltabs.Count; n++)
                {
                    try
                    {
                        builder.MoveToCell(tableindex, pos.row_start + m, pos.cell_start + n, 0);
                        builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                    }
                    catch { }
                }
            }
            maindoc = newdoc;
            maindoc.Protect(ProtectionType.AllowOnlyFormFields);//只读无法编辑，因为没有密码确认 
            this.SaveDocument(maindoc);
        }


        /// <summary>
        /// 打印多个列表
        /// </summary>
        /// <param name="xh"></param>
        public void Print_InfoLists(List<PrintData> pageData, int tableindex)
        {
            List<PositionPro> listpos = new List<PositionPro>();
            Document maindoc = new Document();
            for (int p = 0; p < pageData.Count; p++)
            {
                Document newdoc = new Document(path);
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                List<DataTable> dtinfos = pageData[p].dtinfos;
                Dictionary<string, string> dict = pageData[p].dict;
                List<DataTable> dtlist = pageData[p].dtlist;
                //newdoc.Range.Replace(WordTabChar + "title" + WordTabChar, title, false, false);
                if (dtinfos != null)
                {
                    for (int i = 0; i < dtinfos.Count; i++)
                    {
                        DataTable dtinfo = dtinfos[i];
                        for (int n = 0; n < dtinfo.Columns.Count; n++)
                        {
                            string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                            try
                            {
                                newdoc.Range.Replace(WordTabChar + fieldname.ToLower() + WordTabChar, dtinfo.Rows[0][fieldname].ToString(), false, false);
                            }
                            catch { }
                        }
                    }
                }
                if (dict != null)
                {
                    foreach (string k in dict.Keys)
                    {
                        newdoc.Range.Replace(WordTabChar + k.ToLower() + WordTabChar, dict[k].ToString(), false, false);
                    }
                }
                Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, tableindex, true);//定位table
                if (p == 0)
                {
                    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#"))
                            {
                                PositionPro pos = new PositionPro();
                                pos.row_start = r;
                                pos.cell_start = c;
                                pos.row_end = r;
                                pos.cell_end = c;
                                listpos.Add(pos);
                            }
                            if (dtdoc.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                            {
                                PositionPro pos = listpos.Last<PositionPro>();
                                pos.row_end = r;
                                pos.cell_end = c;
                            }
                        }
                    }
                }
                newdoc.Range.Replace("#START#", "", false, false);
                newdoc.Range.Replace("#END#", "", false, false);
                for (int i = 0; i < dtlist.Count; i++)
                {
                    PositionPro pos = new PositionPro();
                    if (listpos.Count > i)
                    {
                        pos = listpos[i];
                    }
                    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 + 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++)
                                {
                                    PositionPro posnext = listpos[l];
                                    posnext.row_start += 1;
                                    posnext.row_end += 1;
                                }
                            }
                        }
                    }
                    for (int m = 0; m < dt.Rows.Count; m++)
                    {
                        for (int n = 0; n < celltabs.Count; n++)
                        {
                            try
                            {
                                builder.MoveToCell(tableindex, pos.row_start + m, pos.cell_start + n, 0);
                                builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                            }
                            catch { }
                        }
                    }
                }
                if (p == 0)
                {
                    maindoc = newdoc;
                }
                else
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
            }
            //maindoc = newdoc;
            maindoc.Protect(ProtectionType.AllowOnlyFormFields);//只读无法编辑，因为没有密码确认 
            this.SaveDocument(maindoc);
        }

        /// <summary>
        /// 打印多个列表(图片)
        /// </summary>
        /// <param name="xh"></param>
        public void Print_InfoLists(List<PrintData> pageData, int tableindex, bool img)
        {
            List<PositionPro> listpos = new List<PositionPro>();
            Document maindoc = new Document();
            for (int p = 0; p < pageData.Count; p++)
            {
                Document newdoc = new Document(path);
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                List<DataTable> dtinfos = pageData[p].dtinfos;
                Dictionary<string, string> dict = pageData[p].dict;
                List<DataTable> dtlist = pageData[p].dtlist;
                if (dtinfos != null)
                {
                    for (int i = 0; i < dtinfos.Count; i++)
                    {

                        DataTable dtinfo = dtinfos[i];
                        #region 照片
                        if (i == 0 && img == true)
                        {
                            
                            string url = "../.../../zj.jpg";//照片的路径
                            
                            if (url != "")
                            {
                                newdoc.Range.Replace(WordTabChar + "photoxj" + WordTabChar, "#photoxj#", false, false);
                                Regex reg = new Regex("#photoxj#");
                                newdoc.Range.Replace(reg, new ReplaceImage(url), true);
                            }
                            else
                            {
                                newdoc.Range.Replace(WordTabChar + "photoxj" + WordTabChar, "", false, false);
                            }
                        }
                        #endregion

                        for (int n = 0; n < dtinfo.Columns.Count; n++)
                        {
                            string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                            try
                            {
                                newdoc.Range.Replace(WordTabChar + fieldname.ToLower() + WordTabChar, dtinfo.Rows[0][fieldname].ToString(), false, false);
                            }
                            catch { }
                        }
                    }
                }
                if (dict != null)
                {
                    foreach (string k in dict.Keys)
                    {
                        newdoc.Range.Replace(WordTabChar + k.ToLower() + WordTabChar, dict[k].ToString(), false, false);
                    }
                }
                Aspose.Words.Tables.Table dtdoc = (Aspose.Words.Tables.Table)newdoc.GetChild(NodeType.Table, tableindex, true);//定位table
                if (p == 0)
                {
                    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#"))
                            {
                                PositionPro pos = new PositionPro();
                                pos.row_start = r;
                                pos.cell_start = c;
                                pos.row_end = r;
                                pos.cell_end = c;
                                listpos.Add(pos);
                            }
                            if (dtdoc.Rows[r].Cells[c].Range.Text.ToLower().Contains("#end#"))
                            {
                                PositionPro pos = listpos.Last<PositionPro>();
                                pos.row_end = r;
                                pos.cell_end = c;
                            }
                        }
                    }
                }
                newdoc.Range.Replace("#START#", "", false, false);
                newdoc.Range.Replace("#END#", "", false, false);
                for (int i = 0; i < dtlist.Count; i++)
                {
                    PositionPro pos = new PositionPro();
                    if (listpos.Count > i)
                    {
                        pos = listpos[i];
                    }
                    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 + 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++)
                                {
                                    PositionPro posnext = listpos[l];
                                    posnext.row_start += 1;
                                    posnext.row_end += 1;
                                }
                            }
                        }
                    }
                    for (int m = 0; m < dt.Rows.Count; m++)
                    {
                        for (int n = 0; n < celltabs.Count; n++)
                        {
                            try
                            {
                                builder.MoveToCell(tableindex, pos.row_start + m, pos.cell_start + n, 0);
                                builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                            }
                            catch { }
                        }
                    }
                }
                if (p == 0)
                {
                    maindoc = newdoc;
                }
                else
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
            }
            maindoc.Protect(ProtectionType.AllowOnlyFormFields);//只读无法编辑，因为没有密码确认 
            this.SaveDocument(maindoc);
        }



        public void Print_InfoZdzm(DataTable dtinfo)
        {
            Document maindoc = new Document();
            for (int c = 0; c < dtinfo.Rows.Count; c++)
            {
                Document newdoc = new Document(path);
                DocumentBuilder builder = new DocumentBuilder(newdoc);
                newdoc.Range.Replace(WordTabChar + "title" + WordTabChar, title, false, false);
                for (int n = 0; n < dtinfo.Columns.Count; n++)
                {
                    string fieldname = dtinfo.Columns[n].ColumnName.ToLower();
                    string fieldtext = dtinfo.Rows[c][fieldname].ToString();
                    try
                    {
                        newdoc.Range.Replace(WordTabChar + fieldname.ToLower() + WordTabChar, fieldtext, false, false);
                    }
                    catch { }
                }
                //Dictionary<string, string> dict = list[c];
                //if (dict != null)
                //{
                //    foreach (string k in dict.Keys)
                //    {
                //        newdoc.Range.Replace(WordTabChar + k.ToLower() + WordTabChar, dict[k].ToString(), false, false);
                //    }
                //}
                if (c == 0)
                {
                    maindoc = newdoc;
                }
                else
                {
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
            }
            Dotype = "word";
            this.SaveDocument(maindoc);
            //maindoc.Save(filename + ".doc", SaveFormat.Doc, SaveType.OpenInWord, HttpContext.Current.Response);

        }




    }




//转文本
public class ReplaceText : IReplacingCallback
    {
        /// <summary>         
        /// 需要插入的图片路径        
        /// </summary>
        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;
        }
    }
//html格式转文本

    public class ReplaceHtml : IReplacingCallback
    {
        /// <summary>         
        /// 需要插入的图片路径        
        /// </summary>
        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;
        }
    }
//插入图片
    public class ReplaceImage : IReplacingCallback
    {
        /// <summary>         
        /// 需要插入的图片路径        
        /// </summary>
        public string ImageUrl { get; set; }
        //
        public ReplaceImage(string url)
        {
            this.ImageUrl = url;
        }
        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);
                Shape shape = new Shape(doc, ShapeType.Image);
                shape.ImageData.SetImage(ImageUrl);
                shape.Top = 0;
                shape.Width = 80;
                shape.Height = 104;
                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 PrintData
    {
        public List<DataTable> dtinfos;
        public Dictionary<string, string> dict;
        public List<DataTable> dtlist;
    }

}

 

 

 

 

 

调用方法：

 

 

protected void btnzdzm_Click(object sender, EventArgs e)
        {
            string path = Server.MapPath("../xxx/xxx.doc");
            PrintClass printc = new PrintClass();
            printc.path = path;
            printc.filename = "xxxxx";
          
            


            string sql = string.Format(@"select xx1,xx2,xx3 from infoxinx");
            DataTable dtinfo = SqlData.ExecuteDataset(GetSetting(), CommandType.Text, sql).Tables[0];//链接数据库信息返回DataTable
            

            printc.Print_InfoZdzm(dtinfo);

        }

 

 

 

 

 

 

 

 

 

筱筱脱脱
关注
利用Aspose.Words打印word文档
keep innocent
09-13 6134
Aspose.Words是一款先进的类库，可以直接在各个应用程序中执行各种文档处理，即使在没有Microsoft word 的情况下，仍然可以生成，更改，转换，渲染和打印word文档，并且支持DOC，PDF等其他格式。          下面就以  Aspose.Words如何实现打印word文档为例做一个小demo。 1·制作word模板       在word模板中，在需要插入的地方选
aspose.word 批量打印
04-03
aspose 组件中的 aspose.word 做word批量打印 脱离了office的相关dll
没有安装Microsoft Words的情况下读写Word文档的控件Aspose.Words​
weixin_34326558的博客
06-21 187
2019独角兽企业重金招聘Python工程师标准>>> ...
C# aspose word实现模板方式打印及打印速度慢解决方法
u013811335的专栏
04-17 665
1.引用dll nuget或者网上都有下载的方式。不过都要收费。下载地址：https://files.cnblogs.com/files/rolayblog/Tool.zip?t=1713322422&download=true 2.打印模板设计 新建一个doc文档，根据自己的需求画页面。 A、普通文本 在word中需要替换值的地方添加书签，插入>书签，书签名字最好是值的关键字。 ...
借助 Aspose.Words，在 Word 文档中创建表格
最新发布
励志做最业余的专业博主，控件产品可以私我~
08-12 1326
本文通过代码示例展示了在DOCX文件中创建表格的各种方法，欢迎查阅~
使用Aspose来打印Word
07-18
Aspose来打印word，是比较常用的方法，如果有什么问题请留言。使用的方法看主页的文章介绍。
C#实现打印与打印预览功能
weixin_30711917的博客
09-25 419
在windows应用程序中文档的打印是一项非常重要的功能，在以前一直是一个非常复杂的工作,Microsoft .Net Framework的打印功能都以组件的方式提供，为程序员提供了很大的方便，但是这几个组件的使用还是很复杂的，有必要解释一下。 打印操作通常包括以下四个功能: 1 打印设置 设置打印机的一些参数,比如更改打印机驱动程序等; 2 页面设置 设置页面大小纸张类型等 ...
aspose模板导出word及pdf打印
10-15
aspose模板导出word及pdf打印.
使用aspose将word转为pdf
02-28
在本主题中，我们将深入探讨如何使用Aspose这个强大的API库来将Microsoft Word文档转换为PDF格式。Aspose是一个全面的文件处理工具，支持多种格式，包括Word、Excel、PDF等，提供方便的API供开发者集成到他们的应用...
jar java用aspose.word18.8带license
11-09
Aspose.Word是一个完全独立的库，无需安装Microsoft Office，即可在Java环境中创建、编辑、转换和打印Word文档。以下是关于使用Aspose.Word 18.8的一些关键知识点： 1. **安装与引入**：首先，你需要将Aspose.Word...
Aspose.Word域套打示例
11-01
- 使用`MailMerge`方法，传入数据源（如DataTable、List或其他自定义类型），Aspose.Word会自动匹配并替换文档中的域内容。 3. **域套打流程** - 创建数据源：这可以是任何可遍历的数据结构，如数组、列表或...
Asp.net word教程，适合打印
06-13
本资源系实践入门教材，是职业技术学院培训教程，较为容易上手，且具有源代码，适合初学者使用
.net 对word的打印
08-25
.net word 的打印
aspose在线预览office文档
11-19
aspose支持.NET 4.0 可用。在线预览office组件。Asp.net/C#都能使用，不需要安装office软件可以对word、pdf进行操作
C# Aspose.Words调取打印机列表打印相关文件
weixin_40029679的博客
11-08 476
aspose word 打印的相关方法，参数一目了然。
Aspose.Words for .NET使用教程（四）：渲染和打印及文档内容功能
Aote222的博客
01-21 847
Aspose.Words无需Microsoft Word也可在任何平台上满足Word文档的一切操作需求。本文将以表格的形式与大家分享Aspose.Words for .NET的渲染和打印及文档内容功能。 下表总结并比较了Aspose.Words for .NET的功能可用性。欢迎收藏~ 渲染和打印 Aspose.Words提供文档页面的高保真渲染。 功能 .NET .NET S...
Aspose.Words将Word模板打印出来
weixin_30404405的博客
09-07 218
利用Aspose.Words将制作好的模板，输出出来自己所需的文件 /// <summary> /// 打印信息和列表 /// </summary> /// <param name="dtinfo"></param> /// <param name="dtlis...
aspose word 获取标题
07-27
您可以使用Aspose.Words来获取Word文档中的标题。以下是一个示例代码，展示了如何使用Aspose.Words来获取文档的标题： ```csharp using Aspose.Words; // 加载Word文档 Document doc = new Document("input.docx"); // 获取文档的第一个段落 Paragraph firstParagraph = doc.FirstSection.Body.FirstParagraph; // 获取段落的标题 string title = firstParagraph.GetText(); // 打印标题 Console.WriteLine("文档标题: " + title); ``` 在上述代码中，我们首先加载了一个Word文档，然后获取了文档的第一个段落。接下来，我们使用`GetText`方法从段落中获取文本内容，并将其作为标题打印出来。 请注意，以上示例假设文档的标题位于第一个段落中。如果标题位于其他位置或具有特定的样式，请根据需要进行相应的修改。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值