ASP.NET基于Aspose.Words插入Word水印以及多个水印

最新推荐文章于 2024-08-16 09:11:07 发布
置顶 最新推荐文章于 2024-08-16 09:11:07 发布
阅读量1.9k 收藏
点赞数 1
分类专栏： ASp.net 文章标签： ASP.NET word Aspose.Words 水印 

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 xxxxx{
         public class Print{
                   

                       #region 打印多个模板拼接成word


        public Document printDocumentAllWordMore(List<PrintData> datalist)
        {
            int p = 0;
            Document maindoc = new Document();
            foreach (var page in datalist)
            {
                Document newdoc = new Document(page.wordpath);
                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();
                                    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);//确认模板有第二行


                                    //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.MoveToSection(kk);
                                        //builder.MoveTo(newdoc.Sections[kk].Body.Tables[mm].Rows[pos.row_start + m].Cells[pos.cell_start + n].Paragraphs[0].Runs[0]);
                                        builder.MoveToCell(pos.tableindex, pos.row_start + m, pos.cell_start + n, 0);
                                        builder.Write(dt.Rows[m][celltabs[n].ToString()].ToString());
                                    }
                                    catch { }
                                }
                            }




                        }


                        //dataindex = 0;
                        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;
        }


        public void PrintMoreMb(List<List<PrintData>> datalist) 
        {
            if (datalist.Count > 0)
            {
                Document maindoc = printDocumentAllWordMore(datalist[0]);
                Document newdoc = new Document();
                for (int i = 1; i < datalist.Count; i++)
                {
                    newdoc = printDocumentAllWordMore(datalist[i]);
                    newdoc.FirstSection.PageSetup.SectionStart = SectionStart.NewPage;
                    maindoc.AppendDocument(newdoc, ImportFormatMode.KeepSourceFormatting);
                }
                maindoc.Protect(ProtectionType.AllowOnlyFormFields,"mima");
                WaterMark(maindoc, HttpContext.Current.Session["LRXSMC_SH"].ToString());
                //WaterMarkMore(maindoc, HttpContext.Current.Session["LRXSMC_SH"].ToString());
                this.SaveDocument(maindoc);
            }
            
        }


        //public Object apply(Shape watermark)
        //{
        //    watermark.setRelativeHorizontalPosition(RelativeHorizontalPosition.MARGIN);
        //    watermark.setRelativeVerticalPosition(RelativeVerticalPosition.MARGIN);
        //    watermark.setWrapType(WrapType.NONE);
        //    //  我们需要自定义距离顶部的高度      
        //    // watermark.setVerticalAlignment(VerticalAlignment.TOP);
        //    watermark.setHorizontalAlignment(HorizontalAlignment.CENTER);
        //    // 设置距离顶部的高度
        //    watermark.setTop(160);


        //    return null;
        //}


        /// <summary>
        /// 插入多个水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印文字名</param>
        /// <param name="left">左边距多少</param>
        /// <param name="top">上边距多少</param>
        /// <returns></returns>
        public static Shape ShapeMore(Document mdoc, string wmText, double left, double top) 
        {
            Shape waterShape = new Shape(mdoc, ShapeType.TextPlainText);
            //设置该文本的水印
            waterShape.TextPath.Text = wmText;
            waterShape.TextPath.FontFamily = "宋体";
            waterShape.Width = 50;
            waterShape.Height = 50;
            //文本将从左下角到右上角。
            waterShape.Rotation = 0;
            //绘制水印颜色
            waterShape.Fill.Color = System.Drawing.Color.Gray;//浅灰色水印
            waterShape.StrokeColor = System.Drawing.Color.Gray;
            //将水印放置在页面中心
            waterShape.Left = left;
            waterShape.Top = top;
            waterShape.WrapType = WrapType.None;
            return waterShape;
        }


        /// <summary>
        /// 插入多个水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印文字名</param>
        public static void WaterMarkMore(Document mdoc, string wmText)
        {
            Paragraph watermarkPara = new Paragraph(mdoc);
            for (int j = 20; j < 500; j = j + 100) 
            {
                for (int i = 20; i < 700; i = i + 50)
                {
                    Shape waterShape = ShapeMore(mdoc, wmText, j, i);
                    watermarkPara.AppendChild(waterShape);
                }
            }
            
            // 在每个部分中，最多可以有三个不同的标题，因为我们想要出现在所有页面上的水印，插入到所有标题中。  
            foreach (Section sect in mdoc.Sections)
            {
                // 每个区段可能有多达三个不同的标题，因为我们希望所有页面上都有水印，将所有的头插入。
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderPrimary);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderFirst);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderEven);
            }
        }




        /// <summary>
        /// 插入水印
        /// </summary>
        /// <param name="mdoc">Document</param>
        /// <param name="wmText">水印名称</param>
        public static void WaterMark(Document mdoc, string wmText)
        {
            Shape waterShape = new Shape(mdoc, ShapeType.TextPlainText);
            //设置该文本的水印
            waterShape.TextPath.Text = wmText;        
            waterShape.TextPath.FontFamily = "宋体";
            waterShape.Width = 200;
            waterShape.Height = 100;
            //文本将从左下角到右上角。
            waterShape.Rotation = -40;
            //绘制水印颜色
            waterShape.Fill.Color = System.Drawing.Color.Gray;//浅灰色水印
            waterShape.StrokeColor = System.Drawing.Color.Gray;


            //waterShape.Fill.Color = System.Drawing.Color.FromName("#DFF1DF");//浅灰色水印
            //waterShape.StrokeColor = System.Drawing.Color.Gray;


            //将水印放置在页面中心
            //waterShape.Left = 200;
            //waterShape.Top = 600;
            waterShape.RelativeHorizontalPosition = RelativeHorizontalPosition.Page;
            waterShape.RelativeVerticalPosition = RelativeVerticalPosition.Page;
            waterShape.WrapType = WrapType.None;
            waterShape.VerticalAlignment = VerticalAlignment.Center;
            waterShape.HorizontalAlignment = HorizontalAlignment.Center;


            // 创建一个新段落并在该段中添加水印。 
            Paragraph watermarkPara = new Paragraph(mdoc);
            watermarkPara.AppendChild(waterShape);           


            // 在每个部分中，最多可以有三个不同的标题，因为我们想要出现在所有页面上的水印，插入到所有标题中。  
            foreach (Section sect in mdoc.Sections)
            {
                // 每个区段可能有多达三个不同的标题，因为我们希望所有页面上都有水印，将所有的头插入。
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderPrimary);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderFirst);
                InsertWatermarkIntoHeader(watermarkPara, sect, HeaderFooterType.HeaderEven);
            }
        }
        private static void InsertWatermarkIntoHeader(Paragraph watermarkPara, Section sect, HeaderFooterType headerType)
        {
            HeaderFooter header = sect.HeadersFooters[headerType];


            if (header == null)
            {
                // 当前节中没有指定类型的头，创建它
                header = new HeaderFooter(sect.Document, headerType);
                sect.HeadersFooters.Add(header);
            }


            // 在头部插入一个水印的克隆
            header.AppendChild(watermarkPara.Clone(true));
        }






        #endregion




private void SaveDocument(Document doc)
        {
            //SaveOptions saveop = SaveOptions.CreateSaveOptions(filename + ".doc");
            //doc.Save(HttpContext.Current.Response, filename + ".doc", ContentDisposition.Attachment, saveop);
            if (Dotype.Equals("word"))
            {
                SaveOptions saveop = SaveOptions.CreateSaveOptions(filename + ".doc");
                doc.Save(HttpContext.Current.Response, filename + ".doc", ContentDisposition.Attachment, saveop);
            }
            else if (Dotype.Equals("pdf"))
            {
                
                filename = filename + ".pdf";
                string dirpath = HttpContext.Current.Server.MapPath("~/FlexPaper/docs");
                if (!Directory.Exists(dirpath))
                {
                    Directory.CreateDirectory(dirpath);
                }
                string strpath = dirpath + "/" + filename;
                if (File.Exists(strpath))
                {
                    File.Delete(strpath);
                }
                doc.Save(strpath, SaveFormat.Pdf);
                FileInfo fileInfo = new FileInfo(strpath);
                HttpContext.Current.Response.Clear();
                HttpContext.Current.Response.ClearContent();
                HttpContext.Current.Response.ClearHeaders();
                filename = System.Web.HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8);
                HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + filename);
                HttpContext.Current.Response.AddHeader("Content-Length", fileInfo.Length.ToString());
                HttpContext.Current.Response.AddHeader("Content-Transfer-Encoding", "binary");
                HttpContext.Current.Response.ContentType = "application/octet-stream";
                //Response.ContentEncoding = System.Text.Encoding.UTF8;
                HttpContext.Current.Response.WriteFile(fileInfo.FullName);
                HttpContext.Current.Response.Flush();
                HttpContext.Current.Response.End();
            }
            
        }
          

        }

 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;
        }
    }


    public class ReplaceHtml : IReplacingCallback
    {
        /// <summary>         
        /// 替换为html格式      
        /// </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;
        public string wordpath;
    }




    public class PositionProChildren
    {
        public int tableindex { get; set; }
        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;
            }
        }
    }



}





筱筱脱脱
关注
专栏目录
Aspose.Words 去水印版
10-11
去除了“Evaluation Only. Created with Aspose.Words. Copyright 2003-2011 Aspose Pty Ltd.”水印 word,pdf等相互转换，相信对需要的朋友有帮组
Aspose.words之插入水印
夫礼者的专栏
11-17 7780
使用aspose.words为Word插入水印
Aspose.Words for .NET 使用教程
最新发布
gitblog_00118的博客
08-16 499
Aspose.Words for .NET 使用教程 项目地址:https://gitcode.com/gh_mirrors/as/Aspose.Words-for-.NET 1. 项目的目录结构及介绍 Aspose.Words for .NET 项目的目录结构如下： Aspose.Words-for-.NET/ ├── Examples/ │ ├── BasicOperations/ │ ...
【Aspose教程】Aspose.Words for .NET使用教程（一）：基本介绍
Aote222的博客
01-10 3812
Aspose.Words for .NET是一个类库，使你的应用程序能够执行各种文档处理任务。Aspose.Words支持DOC，DOCX，RTF，HTML，OpenDocument，PDF，XPS，EPUB和其他格式。 使用Aspose.Words，你无需使用MicrosoftWord®即可生成，修改，转换，渲染和打印文档。                                   ...
Aspose.Words如何在文档中添加水印
bruce135lee的专栏
08-08 4652
 Aspose.Words是一款先进的文档处理控件，在不使用Microsoft Words的情况下，它可以使用户在各个应用程序中执行各种文档处理任务，其中包括文档的生成、修改、渲染、打印，文档格式转换和邮件合并等文档处理。此外，Aspose.Words支持DOC，OOXML，RTF，HTML，OpenDocument, PDF, XPS, EPUB和其他格式。        有时你需要在一个Wo...
.NET Core Aspose Word(.doc,docx)文件加水印
weixin_42098295的博客
03-17 1020
Aspose.Words是一个强大的库，允许开发者在.NET应用中创建、修改、转换和渲染Word文档，利用Aspose组件给word文件加水印，性能比较好，也比较快，格式兼容性也挺好。另外服务器或PC上不用安装msoffice word软件就可以使用。
asp.net下用Aspose.Words for .NET动态生成word文档中的图片或水印的方法
10-29
本教程将详细解释如何使用Aspose.Words来动态地在ASP.NET应用程序中生成包含图片和水印的Word文档。 1. **加载图片** 要在Word文档中插入图片，你需要使用`Aspose.Words.Drawing.Shape`类。这个类提供了一种方法来...
Aspose.Words 19.11（.net core 可用）
06-02
Aspose.Words是一款强大的文档处理...总之，Aspose.Words 19.11是一个针对.NET Core 3.1的高效、全面的Word文档处理工具，其强大的功能和免费无水印的特性，使其成为开发者在跨平台场景下处理Word文档的首选解决方案。
基于ASP.NET MVC项目源码完整下载(含Aspose.Cells、Aspose.Words、NPOI、MvcPaper及在线预览Word、Excel等文档
01-30
基于ASP.NET MVC框架的学习项目，包含MVC的框架的设计思路，通俗易懂学习MVC框架，项目中包含NPOI控件的使用方法（优点：导出几万条数据几秒即可下载下来）以及NPOI导出Excel表到数据库，Aspose.Cells的使用（导入、...
Aspose.Words for .NET 14.10.7z
01-21
Aspose.Words for .NET是Aspose公司推出的一款强大的文档处理组件，主要用于.NET应用程序中创建、编辑、转换和渲染各种文档格式。版本14.10.7z提供了该组件的无水印版本，这意味着开发者在试用或开发过程中不会看到...
.NET版Word处理控件Aspose.words功能演示：在ASP.NET MVC中创建MS Word编辑器
励志做最业余的专业博主，控件产品可以私我~
08-30 368
您可以使用相同的内容，也可以选择其他任何适合您要求的HTML编辑器。Aspose.Words for .NET提供了一套完整的功能，用于在多个.NET应用程序中操作和转换MS Word文档。您可以在桌面或Web应用程序中创建新的或编辑现有的Word文档。在本文中，将展示如何利用Aspose.Words for .NET的字处理功能，以及如何在ASP.NET MVC中创建基于Web的MS Word编辑器。在ASP.NET MVC中创建MS Word编辑器的步骤。...
aspose-words word添加水印的jar和licence文件
10-09
支持word水印，包含licence文件和jar包，支持doc和docx 支持word水印
Aspose.Words 11.7 去水印版
11-16
去除了“Evaluation Only. Created with Aspose.Words. Copyright 2003-2011 Aspose Pty Ltd.”水印 word,pdf等相互转换，相信对需要的朋友有帮组
PDF加水印（C#源码）
10-13
C#写了一个简单的给PDF加水印的工具，水印图片可自定义，程序可直接运行，内含源码，亲测可用！
c# word /pdf添加水印
10-21
用的是office 组件实现给word 文档添加水印，水印的类型有图片水印，文字水印， 使用Spire.Pdf.dll 给pdf 添加水印
Word处理控件Aspose.Words功能演示：在 ASP.NET 中使用 C# 比较两个 Word 文档
励志做最业余的专业博主，控件产品可以私我~
03-23 611
此应用程序将具有以下功能。为了在没有 MS Office 的情况下执行 Word 文档的比较，我们将使用Aspose.Words for .NET，它是一个用于 ASP.NET 或其他 .NET/.NET Core 应用程序的强大的文字处理 API。
Aspose.Words图片水印
scys1217的专栏
06-06 4565
1、概述 　　在项目中生成word文档，这个功能很普遍的，一般生成都是纯文字或是列表的比较多，便于客户打印，而要把图片也生成到word文档中的需求有些客户也是需要的，例如产品图片。这次我们介绍的是如何利用Aspose.Words for .NET在Word中动态的生成图片或水印。Aspose.Words for .NET，这个我就不多介绍了，不清楚的朋友可以看看上一篇文章。需求总是变化得快，最近
aspose给word添加水印
xzj80927的博客
10-22 3323
第一步：引入依赖 <dependency> <groupId>com.aspose</groupId> <artifactId>aspose-words</artifactId> <version>16.6.0</version> </dependency> 第二步：添加水印 1、添加一个文字水印到内容中 /*
Word格式处理控件Aspose.Words for .NET水印处理教程——如何添加和删除水印
励志做最业余的专业博主，控件产品可以私我~
07-08 1720
Aspose.Words For .NET是一种高级Word文档处理API，用于执行各种文档管理和操作任务。API支持生成，修改，转换，呈现和打印文档，而无需在跨平台应用程序中直接使用Microsoft Word。此外，API支持所有流行的Word处理文件格式，并允许将Word文档导出或转换为固定布局文件格式和最常用的图像/多媒体格式。接下来我们将进入关于“水印处理”的介绍，在Aspose.Words中学会如何添加和删除水印。在文档中添加水印有时，如果想打印草稿文件或将其标记为机密文件，则需要在Word文档
.net core aspose.words
11-17
Aspose.Words 是一个针对 .NET Core 平台的强大的文档处理库。它可以用于创建、读取、修改和转换多种类型的文档，如 Word、PDF、HTML、ePub 等。.NET Core 是微软开发的一种开源、跨平台的框架，用于构建高性能、可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值