OpenXML操作word

最新推荐文章于 2024-08-09 07:10:12 发布
最新推荐文章于 2024-08-09 07:10:12 发布
阅读量382 收藏 1
点赞数
原文链接：http://www.cnblogs.com/wardensky/p/5482199.html
版权

OpenXML概述

项目中经常需要操作word，之前的方式是采用COM接口，这个接口很不稳定，经常报错。现在开始采用OpenXML。OpenXML（OOXML）是微软在Office 2007中提出的一种新的文档格式，Office 2007中的Word、Excel、PowerPoint默认均采用OpenXML格式 。
OpenXml相对于用MS提供的COM组件来生成WORD,有如下优势:

1.相对于MS 的COM组件,因为版本带来的不兼容问题,及各种会生成WORD半途会崩溃的问题.
2.对比填满一张30多页的WORD来说(包含图,表等),用COM组件来生成会占用20秒,Openxml1秒.
3.MS Word软件太贵了,你的客户装的是开源WORD,如LibreOffice,OpenOffice.这样你就只能用Openxml生成的WORD文档,各种支持MS Word都能打开,避免客户机器上安装MS Word.
4.代码简单。用OpenXML开发word简直太方便了！！！

要做OpenXML的开发，需要了解OpenXML的基本结构。
239608-20160511155646765-1679984141.png

Open XML SDK 2.0 tool

因为OpenXML的结构比较复杂，开始开发时往往不好入门，摸不清其结构。微软很贴心的提供了一个工具，Open XML SDK Productivity Tool for Microsoft Office。
下载地址
这个工具可以打开任意一个docx的文档，然后Reflect Code，得到整个文档代码，之后怎么操作直接看代码就好了，真是太方便了。

另外这个工具也提供了文档，不清楚的可以查一下文档。

代码示例

我参考上面的工具，写了一个简单的操作word的帮助类。

using System.Collections.Generic;
using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using AA = DocumentFormat.OpenXml.Drawing;
using DW = DocumentFormat.OpenXml.Drawing.Wordprocessing;
using PIC = DocumentFormat.OpenXml.Drawing.Pictures;

namespace Wisdombud.Office
{
    public static class OpenXmlUtil
    {

        /// <summary>
        /// 按书签替换图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        /// <param name="x">宽度厘米</param>
        /// <param name="y">高度厘米</param>
        /// <param name="type"></param>
        public static void ReplaceBMPicture(string filePath, string picPath, string bm)
        {
            RemoveBookMarkContent(filePath, bm);
            InsertBMPicture(filePath, picPath, bm);
        }

        /// <summary>
        /// 按书签替换图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        /// <param name="x">宽度厘米</param>
        /// <param name="y">高度厘米</param>
        /// <param name="type"></param>
        public static void ReplaceBMPicture(string filePath, string picPath, string bm, long x, ImagePartType type)
        {
            RemoveBookMarkContent(filePath, bm);
            InsertBMPicture(filePath, picPath, bm, x, type);
        }
        /// <summary>
        /// 按书签替换图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        /// <param name="x">宽度厘米</param>
        /// <param name="y">高度厘米</param>
        /// <param name="type"></param>
        public static void ReplaceBMPicture(string filePath, string picPath, string bm, long x, long y, ImagePartType type)
        {
            RemoveBookMarkContent(filePath, bm);
            InsertBMPicture(filePath, picPath, bm, x, y, type);
        }
        /// <summary>
        /// 按书签插入图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        /// <param name="x">宽度厘米</param>
        /// <param name="y">高度厘米</param>
        /// <param name="type"></param>
        public static void InsertBMPicture(string filePath, string picPath, string bm, long x, ImagePartType type)
        {
            long y = 0;
            using (System.Drawing.Bitmap objPic = new System.Drawing.Bitmap(picPath))
            {
                y = (x * objPic.Height) / objPic.Width;
            }
            InsertBMPicture(filePath, picPath, bm, x, y, type);
        }

        /// <summary>
        /// 按书签插入图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        /// <param name="x">宽度厘米</param>
        /// <param name="y">高度厘米</param>
        /// <param name="type"></param>
        public static void InsertBMPicture(string filePath, string picPath, string bm, long x, long y, ImagePartType type)
        {
            using (WordprocessingDocument doc =
               WordprocessingDocument.Open(filePath, true))
            {
                MainDocumentPart mainPart = doc.MainDocumentPart;

                BookmarkStart bmStart = findBookMarkStart(doc, bm);
                if (bmStart == null)
                {
                    return;
                }

                ImagePart imagePart = mainPart.AddImagePart(type);

                using (FileStream stream = new FileStream(picPath, FileMode.Open))
                {
                    imagePart.FeedData(stream);
                }
                long cx = 360000L * x;//360000L = 1厘米
                long cy = 360000L * y;
                Run r = AddImageToBody(doc, mainPart.GetIdOfPart(imagePart), cx, cy);
                bmStart.Parent.InsertAfter<Run>(r, bmStart);
                mainPart.Document.Save();
            }
        }
        /// <summary>
        /// 按书签插入图片。默认15厘米，JPG
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="picPath"></param>
        /// <param name="bm"></param>
        public static void InsertBMPicture(string filePath, string picPath, string bm)
        {
            InsertBMPicture(filePath, picPath, bm, 15, 15, ImagePartType.Jpeg);
        }
        /// <summary>
        /// 查找书签
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="bmName"></param>
        /// <returns></returns>
        private static BookmarkStart findBookMarkStart(WordprocessingDocument doc, string bmName)
        {
            foreach (var footer in doc.MainDocumentPart.FooterParts)
            {
                foreach (var inst in footer.Footer.Descendants<BookmarkStart>())
                {
                    if (inst.Name == bmName)
                    {
                        return inst;
                    }
                }
            }

            foreach (var header in doc.MainDocumentPart.HeaderParts)
            {
                foreach (var inst in header.Header.Descendants<BookmarkStart>())
                {
                    if (inst.Name == bmName)
                    {
                        return inst;
                    }
                }
            }
            foreach (var inst in doc.MainDocumentPart.RootElement.Descendants<BookmarkStart>())
            {
                if (inst is BookmarkStart)
                {
                    if (inst.Name == bmName)
                    {
                        return inst;
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// 查找书签
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="bmName"></param>
        /// <returns></returns>
        private static List<BookmarkStart> findAllBookMarkStart(WordprocessingDocument doc)
        {
            List<BookmarkStart> ret = new List<BookmarkStart>();
            foreach (var footer in doc.MainDocumentPart.FooterParts)
            {
                ret.AddRange(footer.Footer.Descendants<BookmarkStart>());

            }
            foreach (var header in doc.MainDocumentPart.HeaderParts)
            {
                ret.AddRange(header.Header.Descendants<BookmarkStart>());
            }
            ret.AddRange(doc.MainDocumentPart.RootElement.Descendants<BookmarkStart>());
            return ret;
        }
        /// <summary>
        /// 查找书签
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="bmName"></param>
        /// <returns></returns>
        private static List<BookmarkEnd> findAllBookMarkEnd(WordprocessingDocument doc)
        {
            List<BookmarkEnd> ret = new List<BookmarkEnd>();
            foreach (var footer in doc.MainDocumentPart.FooterParts)
            {
                ret.AddRange(footer.Footer.Descendants<BookmarkEnd>());

            }
            foreach (var header in doc.MainDocumentPart.HeaderParts)
            {
                ret.AddRange(header.Header.Descendants<BookmarkEnd>());
            }
            ret.AddRange(doc.MainDocumentPart.RootElement.Descendants<BookmarkEnd>());
            return ret;
        }


        /// <summary>
        /// 查找书签END
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="bmName"></param>
        /// <returns></returns>
        private static BookmarkEnd findBookMarkEnd(WordprocessingDocument doc, string id)
        {
            foreach (var footer in doc.MainDocumentPart.FooterParts)
            {
                foreach (var inst in footer.Footer.Descendants<BookmarkEnd>())
                {
                    if (inst.Id == id)
                    {
                        return inst;
                    }
                }
            }

            foreach (var header in doc.MainDocumentPart.HeaderParts)
            {
                foreach (var inst in header.Header.Descendants<BookmarkEnd>())
                {
                    if (inst.Id == id)
                    {
                        return inst;
                    }
                }
            }
            foreach (var inst in doc.MainDocumentPart.RootElement.Descendants<BookmarkEnd>())
            {
                if (inst.Id == id)
                {
                    return inst;
                }

            }

            return null;
        }

        private static Run AddImageToBody(WordprocessingDocument wordDoc, string relationshipId, long cx, long cy)
        {
            return new Run(new Drawing(
                     new DW.Inline(
                         new DW.Extent() { Cx = cx, Cy = cy },
                         new DW.EffectExtent()
                         {
                             LeftEdge = 0L,
                             TopEdge = 0L,
                             RightEdge = 0L,
                             BottomEdge = 0L
                         },
                         new DW.DocProperties()
                         {
                             Id = (UInt32Value)1U,
                             Name = "Picture 1"
                         },
                         new DW.NonVisualGraphicFrameDrawingProperties(
                             new AA.GraphicFrameLocks() { NoChangeAspect = true }),
                         new AA.Graphic(
                             new AA.GraphicData(
                                 new PIC.Picture(
                                     new PIC.NonVisualPictureProperties(
                                         new PIC.NonVisualDrawingProperties()
                                         {
                                             Id = (UInt32Value)0U,
                                             Name = "New Bitmap Image.jpg"
                                         },
                                         new PIC.NonVisualPictureDrawingProperties()),
                                     new PIC.BlipFill(
                                         new AA.Blip(
                                             new AA.BlipExtensionList(
                                                 new AA.BlipExtension()
                                                 {
                                                     Uri =
                                                       "{28A0092B-C50C-407E-A947-70E740481C1C}"
                                                 })
                                         )
                                         {
                                             Embed = relationshipId,
                                             CompressionState =
                                             AA.BlipCompressionValues.Print
                                         },
                                         new AA.Stretch(
                                             new AA.FillRectangle())),
                                     new PIC.ShapeProperties(
                                         new AA.Transform2D(
                                             new AA.Offset() { X = 0L, Y = 0L },
                                             new AA.Extents() { Cx = 990000L, Cy = 792000L }),
                                         new AA.PresetGeometry(
                                             new AA.AdjustValueList()
                                         ) { Preset = AA.ShapeTypeValues.Rectangle }))
                             ) { Uri = "http://schemas.openxmlformats.org/drawingml/2006/picture" })
                     )
                     {
                         DistanceFromTop = (UInt32Value)0U,
                         DistanceFromBottom = (UInt32Value)0U,
                         DistanceFromLeft = (UInt32Value)0U,
                         DistanceFromRight = (UInt32Value)0U,
                         EditId = "50D07946"
                     }));

            // Append the reference to body, the element should be in a Run.
            //  wordDoc.MainDocumentPart.Document.Body.AppendChild(new Paragraph(new Run(element)));
        }

        public static void DeleteRange(string filePath, string stringStart, string stringStop, int way)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                List<OpenXmlElement> list = RangeFind(doc, stringStart, stringStop, way);
                foreach (var inst in list)
                {
                    inst.Remove();
                }
            }
        }
        /// <summary>
        /// 1 标记1结束到标记2开始;2 标记1结束到标记2结束;3 标记1开始到标记2结束; 4 标记1开始到标记2开始;
        /// trimhuiche 如果为true，则考虑回车；否则不考虑回车。
        /// chzhao@wisdombud.com
        /// </summary>
        /// <param name="stringStart"></param>
        /// <param name="stringStop"></param>
        /// <param name="way"></param>
        public static List<OpenXmlElement> RangeFind(WordprocessingDocument doc, string stringStart, string stringStop, int way)
        {
            List<OpenXmlElement> ret = new List<OpenXmlElement>();
            bool add = false;
            foreach (var inst in doc.MainDocumentPart.Document.Body.Elements())
            {

                if (way == 1)
                {
                    if (inst.InnerText.Contains(stringStop))
                    {
                        add = false;
                    }
                    if (add)
                    {
                        ret.Add(inst.CloneNode(true));
                    }
                    if (inst.InnerText == stringStart)
                    {
                        add = true;
                    }
                }
                else if (way == 2)
                {

                    if (add)
                    {
                        ret.Add(inst.CloneNode(true));
                    }
                    if (inst.InnerText == stringStart)
                    {
                        add = true;
                    }
                    if (inst.InnerText.Contains(stringStop))
                    {
                        add = false;
                    }
                }
                else if (way == 3)
                {
                    if (inst.InnerText == stringStart)
                    {
                        add = true;
                    }
                    if (add)
                    {
                        ret.Add(inst.CloneNode(true));
                    }

                    if (inst.InnerText.Contains(stringStop))
                    {
                        add = false;
                    }
                }
                else if (way == 4)
                {
                    if (inst.InnerText == stringStart)
                    {
                        add = true;
                    }
                    if (inst.InnerText.Contains(stringStop))
                    {
                        add = false;
                    }
                    if (add)
                    {
                        ret.Add(inst.CloneNode(true));
                    }

                }



            }
            return ret;
        }


        /// <summary>
        /// 修改书签
        /// </summary>
        /// <param name="filePath">word文档</param>
        /// <param name="bmName">书签名字</param>
        /// <param name="text">替换的文本</param>
        public static void ModifyBM(string filePath, string bmName, string text)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                BookmarkStart bmStart = findBookMarkStart(doc, bmName);

                Run bookmarkText = bmStart.NextSibling<Run>();
                if (bookmarkText != null)
                {
                    Text t = bookmarkText.GetFirstChild<Text>();
                    if (t != null)
                    {
                        t.Text = text;
                    }
                }
            }
        }
        /// <summary>
        /// 删除书签内容
        /// </summary>
        /// <param name="bookmark"></param>
        public static void RemoveBookMarkContent(string filePath, string bmName)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                BookmarkStart bmStart = findBookMarkStart(doc, bmName);
                BookmarkEnd bmEnd = findBookMarkEnd(doc, bmStart.Id);
                while (true)
                {
                    var run = bmStart.NextSibling();
                    if (run == null)
                    {
                        break;
                    }
                    if (run is BookmarkEnd && (BookmarkEnd)run == bmEnd)
                    {
                        break;
                    }

                    run.Remove();
                }

            }
        }
        /// <summary>
        /// 重命名书签，在书签前面加前缀
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="prefix">前缀</param>
        public static void RenameBookMark(string filePath, string prefix)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                foreach (var inst in findAllBookMarkStart(doc))
                {
                    inst.Name = prefix + inst.Name;
                }
            }
        }

        /// <summary>
        /// 重命名书签
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="oldName"></param>
        /// <param name="newName"></param>
        public static void RenameBookMark(string filePath, string oldName, string newName)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                var bm = findBookMarkStart(doc, oldName);
                bm.Name = newName;
            }
        }

        /// <summary>
        /// 删除书签
        /// </summary>
        /// <param name="bookmark"></param>
        public static void RemoveBookMark(string filePath, string bmName)
        {
            using (WordprocessingDocument doc = WordprocessingDocument.Open(filePath, true))
            {
                var bmStart = findBookMarkStart(doc, bmName);
                if (bmStart == null)
                {
                    return;
                }
                var bmEnd = findBookMarkEnd(doc, bmStart.Id);
                bmStart.Remove();
                bmEnd.Remove();

            }
        }
        /// <summary>
        /// 合并文档
        /// </summary>
        /// <param name="finalFile"></param>
        /// <param name="files"></param>
        public static void Combine(string finalFile, List<string> files)
        {
            if (files.Count < 2)
            {
                return;
            }
            File.Copy(files[0], finalFile, true);
            using (WordprocessingDocument doc = WordprocessingDocument.Open(finalFile, true))
            {
                Body b = doc.MainDocumentPart.Document.Body;
                for (int i = 1; i < files.Count; i++)
                {
                    using (WordprocessingDocument doc1 = WordprocessingDocument.Open(files[i], true))
                    {
                        foreach (var inst in doc1.MainDocumentPart.Document.Body.Elements())
                        {
                            b.Append(inst.CloneNode(true));
                        }
                    }
                }
            }
        }
    }
}

转载于:https://www.cnblogs.com/wardensky/p/5482199.html

dcwbi40268
关注
java openxml 操作 word_OpenXML操作word
weixin_34739699的博客
02-17 900
OpenXML概述项目中经常需要操作word，之前的方式是采用COM接口，这个接口很不稳定，经常报错。现在开始采用OpenXML。OpenXML(OOXML)是微软在Office 2007中提出的一种新的文档格式，Office 2007中的Word、Excel、PowerPoint默认均采用OpenXML格式 。OpenXml相对于用MS提供的COM组件来生成WORD,有如下优势:1.相对于MS ...
openxml html to word,使用openxml提取word中的文本和图片并转为Html
weixin_33552230的博客
06-16 770
C# Net Core openxml 提取提出 取word 文本 图片 HtmlTextDrawingC# NetCoreopenxml 提取提出 取 word 文本 图片 HtmlTextDrawing注：只支持内嵌，不支持公式---------------------------------------------------------------文章最后为效果-...
OpenXml读取word内容的实例
08-28
下面小编就为大家分享一篇OpenXml读取word内容的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C# 使用 DocumentFormat.OpenXml 读写 Word 文档
huanqiuda的博客
01-08 5927
最近一个项目涉及到 Word 文档的读写操作，考虑相关工具： 1、Microsoft.Office.Interop.Word : 需要用到 COM 组件 2、NPOI : Java POI 对应 .net 版本 3、DocumentFormat.OpenXml ：无需第三方组件，可通过 NuGet 引用 因项目环境考虑，这里选择DocumentFormat.OpenXml 进行 Word 文档的读写操作。 从文件流 FileStream 中读取 Word 文档，填充内容后，返回字节数组 byt..
Web系统下Office文档的处理 之OpenXml应用分类资料
weixin_34128411的博客
03-24 132
本文对常见的处理参考和工具提供一个简要的参考。 对于实际的解决方案参考如下地址（有很多的分类知识） http://blogs.msdn.com/b/ericwhite/archive/2008/10/20/eric-white-s-blog-s-table-of-contents.aspx  本文对我们常见的处理涉及的几个方面进行一个汇总和参考 另两个参考文章：  Web系统下Offic...
C#使用OpenXml读取Word、PPT、Excel文档内容
花开莫与流年错_的博客
06-14 1355
C#使用OpenXml读取Word、PPT、Excel文档内容
OpenXML操作Word
07-17
下面我们将详细探讨如何使用OpenXML SDK来操作Word文档，包括添加文字、设置文字属性、调整样式和排列效果以及插入图片。 1. 添加文字和文字属性： 使用OpenXML SDK，可以通过`DocumentFormat.OpenXml.Word...
C#采用OpenXml给word里面插入图片
09-04
总的来说，C#通过OpenXml操作Word文档，尤其是插入图片，涉及了文件操作、枚举类型、XML结构理解和API调用等多个方面。理解这些细节对于开发高效、可靠的文档处理程序至关重要。通过不断实践和学习，开发者可以更好...
wordutil:使用openxml在word文档中添加水印和保护
06-22
在IT行业中，尤其是在文档处理领域，OpenXML是一个重要的标准，它允许程序员以编程方式操作Microsoft Office文件，如Word文档（.docx）。本项目“wordutil”是利用C#语言来实现OpenXML功能的一个示例，主要关注在...
报表导出Demo-DocumentFormat.OpenXml
01-08
通过DocumentFormat.OpenXml导出Excel报表的demo(源码),内含Excel导出的示例以及注释,支持大数据导出,不会引起内存溢出等问题,并且导出效率很高,支持公式.里面也有部分word导出的代码.注意,不支持低版本excel(xls格式)的导出
使用 DocumentFormat.OpenXml 将word中的模板字符替换为图片
m0_48940043的博客
03-04 623
使用 DocumentFormat.OpenXml 将word中的模板字符替换为图片
用 DocumentFormat.OpenXml 和Microsoft.Office.Interop.Word 写入或者读取word文件
weixin_30675967的博客
01-14 355
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Xml; namespace MediaTools.Tool { publ...
【转】【OpenXml】OpenXml操作Word的一些操作总结
kakarrot2009的专栏
01-29 211
OpenXml相对于用MS提供的COM组件来生成WORD,有如下优势: 1.相对于MS 的COM组件,因为版本带来的不兼容问题,及各种会生成WORD半途会崩溃的问题. 2.对比填满一张30多页的WORD来说(包含图,表等),用COM组件来生成会占用20秒,Openxml1秒. 3.MS Word软件太贵了,你的客户装的是开源WORD,如LibreOffice,OpenOffice.这样你就只能用...
java openxml word_用 DocumentFormat.OpenXml 和Microsoft.Office.Interop.Word 写入或者读取word文件...
weixin_33253503的博客
02-24 305
usingSystem;usingSystem.Collections.Generic;usingSystem.IO;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;usingSystem.Xml;namespaceMediaTools.Tool{public classWordHelper{public static v...
使用DocumentFormat.OpenXML实现Excel表格转Word表格
always987905790的博客
03-11 3375
特别申明：本帖为原创，在不影响版本的前提下，欢迎转载。入题之前，我们先看一下什么是DocumentFormat.OpenXML？由于Open XML Format格式是开放的，而且基础是大家熟悉的ZIP和XML技术，因此对开发人员来说非常有用。微软也在System.IO.Packaging命名空间里提供了一个开发库，用于访问这些文件，并作为WinFX技术的一部分，同时也是Open XML Form...
Open XML SDK 2.0 for Microsoft Office
weixin_30786657的博客
01-28 301
此OpenXML不支持Excel 2003或者更早的文件格式。只支持Excel 2007及Excel 2010的文件格式。可能是因为从Excel 2007起，这些文件都用xml表示了。xlsx其实是一个zip文件，解开此zip文件，我们可以看到很多描述excel内容的xml文件。 转载于:https://www.cnblogs.com/fdxmfxzqebqf/archive/2012/01/28...
Open XML SDK for Microsoft Office 安装与使用指南
最新发布
gitblog_01047的博客
08-09 397
Open XML SDK for Microsoft Office 安装与使用指南 Open-XML-SDKOpen XML SDK by Microsoft项目地址:https://gitcode.com/gh_mirrors/op/Open-XML-SDK 目录结构及介绍 在安装并克隆了 Open XML SDK 后，你会看到以下主要的目录结构: 1. src 该目录包含了核心的源代码库。在...
C#编程操作Word文档指南
"C#操作Word文档" 在C#中操作Word文档主要依赖于Microsoft Office的自动化接口，使得开发者可以通过编程方式对Word文档进行创建、读取、修改和保存等操作。这一技术通常适用于需要在服务器端生成Word报告、文档合并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值