使用OpenXml操作Excel，创建Excel,导入DataTable的数据

最新推荐文章于 2024-06-26 08:00:00 发布
最新推荐文章于 2024-06-26 08:00:00 发布
阅读量7.4k 收藏 5
点赞数 3
分类专栏： 【001】ASP.NET
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011176794/article/details/52451422
版权 
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.OleDb;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace Testing
{
    public class ExcelUtility
    {
        ///注意:
        ///需要提前添加DocumentFormat.OpenXml.dll
        ///openXml只能处理后缀为xlsx的excel文件，xls格式的不支持
        private object m_objOpt = Missing.Value;

        private DocumentFormat.OpenXml.Packaging.SpreadsheetDocument m_objSpreadsheetDocument = null;
        private WorkbookPart m_objWorkbookPart = null;
        private WorksheetPart m_objWorksheetPart = null;
        private Worksheet m_objWorksheet = null;
        private SheetData m_objSheetData = null;

        List<string> NormalSheets = new List<string>();
        const int BranchCodeRow = 2;
        const int BranchCodeStartCol = 3;
        const int DataEndRow = 7;

        public ExcelUtility() { }

        #region CreateExcel Interop 2007
        /// <summary>
        /// 创建excel,并且把dataTable导入到excel中
        /// </summary>       
        /// <param name="destination">保存路径</param>
        /// <param name="dataTables">数据源</param>
        /// <param name="sheetNames">excel中sheet的名称</param>  
        public void CreateExcel(string destination, DataTable[] dataTables, string[] sheetNames = null)
        {
            using (var workbook = SpreadsheetDocument.Create(destination, DocumentFormat.OpenXml.SpreadsheetDocumentType.Workbook))
            {
                var workbookPart = workbook.AddWorkbookPart();
                workbook.WorkbookPart.Workbook = new DocumentFormat.OpenXml.Spreadsheet.Workbook();
                workbook.WorkbookPart.Workbook.Sheets = new DocumentFormat.OpenXml.Spreadsheet.Sheets();

                uint sheetId = 1;
                bool isAddStyle = false;
                foreach (DataTable table in dataTables)
                {
                    var sheetPart = workbook.WorkbookPart.AddNewPart<WorksheetPart>();
                    var sheetData = new SheetData();
                    sheetPart.Worksheet = new Worksheet();
                    if (!isAddStyle)
                    {
                        var stylesPart = workbook.WorkbookPart.AddNewPart<WorkbookStylesPart>();
                        Stylesheet styles = new CustomStylesheet();
                        styles.Save(stylesPart);
                        isAddStyle = true;
                    }
                    Columns headColumns = CrateColunms(table);
                    sheetPart.Worksheet.Append(headColumns);
                    DocumentFormat.OpenXml.Spreadsheet.Sheets sheets = workbook.WorkbookPart.Workbook.GetFirstChild<DocumentFormat.OpenXml.Spreadsheet.Sheets>();
                    string relationshipId = workbook.WorkbookPart.GetIdOfPart(sheetPart);

                    if (sheets.Elements<DocumentFormat.OpenXml.Spreadsheet.Sheet>().Count() > 0)
                    {
                        sheetId =
                            sheets.Elements<DocumentFormat.OpenXml.Spreadsheet.Sheet>().Select(s => s.SheetId.Value).Max() + 1;
                    }
                    string sheetName = string.Empty;
                    if (sheetNames != null)
                    {
                        if (sheetNames.Length >= sheetId)
                        {
                            sheetName = sheetNames[sheetId - 1].ToString();
                        }
                    }
                    else
                    {
                        sheetName = table.TableName ?? sheetId.ToString();
                    }

                    DocumentFormat.OpenXml.Spreadsheet.Sheet sheet = new DocumentFormat.OpenXml.Spreadsheet.Sheet() { Id = relationshipId, SheetId = sheetId, Name = sheetName };
                    sheets.Append(sheet);

                    DocumentFormat.OpenXml.Spreadsheet.Row headerRow = new DocumentFormat.OpenXml.Spreadsheet.Row();

                    List<String> columns = new List<string>();
                    foreach (DataColumn column in table.Columns)
                    {
                        columns.Add(column.ColumnName);

                        DocumentFormat.OpenXml.Spreadsheet.Cell cell = new DocumentFormat.OpenXml.Spreadsheet.Cell();
                        cell.DataType = DocumentFormat.OpenXml.Spreadsheet.CellValues.String;
                        cell.StyleIndex = 11;
                        cell.CellValue = new DocumentFormat.OpenXml.Spreadsheet.CellValue(column.ColumnName);
                        headerRow.AppendChild(cell);
                    }
                    sheetData.AppendChild(headerRow);

                    foreach (DataRow dsrow in table.Rows)
                    {
                        DocumentFormat.OpenXml.Spreadsheet.Row newRow = new DocumentFormat.OpenXml.Spreadsheet.Row();
                        foreach (String col in columns)
                        {
                            DocumentFormat.OpenXml.Spreadsheet.Cell cell = new DocumentFormat.OpenXml.Spreadsheet.Cell();
                            cell.DataType = DocumentFormat.OpenXml.Spreadsheet.CellValues.String;
                            cell.StyleIndex = 10;
                            cell.CellValue = new DocumentFormat.OpenXml.Spreadsheet.CellValue(dsrow[col].ToString()); //
                            newRow.AppendChild(cell);
                        }
                        sheetData.AppendChild(newRow);
                    }
                    sheetPart.Worksheet.Append(sheetData);
                }
                workbook.Close();
            }
        }

        private Columns CrateColunms(DataTable table)
        {
            int numCols = table.Columns.Count;
            var columns = new Columns();
            for (int col = 0; col < table.Columns.Count; col++)
            {
                int maxWidth = table.Columns[col].ColumnName.Length;
                int valueWidth = 0;
                for (int row = 0; row < table.Rows.Count; row++)
                {
                    valueWidth = table.Rows[row][col].ToString().Trim().Length;
                    if (maxWidth < valueWidth)
                    {
                        maxWidth = valueWidth;
                    }
                }
                Column c = new CustomColumn((UInt32)col + 1, (UInt32)numCols + 1, maxWidth + 5);
                columns.Append(c);
            }
            return columns;
        }

        private SheetData CreateSheetData(DataTable table)
        {
            var sheetData = new SheetData();
            Row headerRow = new Row();

            List<String> columns = new List<string>();
            foreach (DataColumn column in table.Columns)
            {
                columns.Add(column.ColumnName);

                Cell cell = new Cell();
                cell.StyleIndex = 11;
                cell.DataType = CellValues.String;
                cell.CellValue = new CellValue(column.ColumnName);
                headerRow.Append(cell);
            }

            sheetData.Append(headerRow);

            foreach (DataRow dsrow in table.Rows)
            {
                Row newRow = new Row();
                foreach (String col in columns)
                {
                    Cell cell = new Cell();
                    cell.StyleIndex = 10;
                    cell.DataType = CellValues.String;
                    cell.CellValue = new CellValue(dsrow[col].ToString()); //
                    newRow.Append(cell);
                }

                sheetData.Append(newRow);
            }

            return sheetData;
        }
        #endregion

     
        public void ReadExcelFromStream(Stream stream, bool isEditable)
        {
            try
            {
                m_objSpreadsheetDocument = SpreadsheetDocument.Open(stream, isEditable);
                m_objWorkbookPart = m_objSpreadsheetDocument.WorkbookPart;
                m_objWorksheetPart = m_objWorkbookPart.WorksheetParts.First();
                m_objWorksheet = m_objWorksheetPart.Worksheet;
                m_objSheetData = m_objWorksheet.Elements<SheetData>().First();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                this.DisposeRead();
                throw;
            }
        }
        
        /// <summary>
        /// 获取excel中cell的值
        /// </summary>
        /// <param name="columnName"></param>
        /// <param name="rowIndex"></param>
        /// <returns></returns>
        public string GetCellValue(string columnName, int rowIndex)
        {
            Cell cell = GetCell(columnName, rowIndex);
            if (cell == null)
            {
                return string.Empty;
            }
            if (cell.CellValue == null)
            {
                return string.Empty;
            }
            int cellId = Convert.ToInt32(cell.CellValue.Text);
            return m_objWorkbookPart.SharedStringTablePart.SharedStringTable.Elements<SharedStringItem>().ElementAt(cellId).InnerText;
        }

        public Cell GetCell(string columnName, int rowIndex)
        {
            Row row = GetRow(Convert.ToUInt32(rowIndex));

            if (row == null)
            {
                return null;
            }
            return row.Elements<Cell>().Where(c => string.Compare(c.CellReference.Value, columnName + rowIndex, true) == 0).First();
        }

        // Given a worksheet and a row index, return the row.
        public Row GetRow(uint rowIndex)
        {
            if (m_objWorksheet == null)
            {
                return null;
            }
            return m_objWorksheet.GetFirstChild<SheetData>().Elements<Row>().Where(r => r.RowIndex == rowIndex).First();
        }

        public List<Row> GetRows()
        {
            if (m_objSheetData == null)
            {
                return null;
            }
            return m_objSheetData.Elements<Row>().ToList();
        }

        public void CloseRead()
        {
            if (m_objSpreadsheetDocument != null)
            {
                m_objSpreadsheetDocument.Dispose();
            }
        }

        public void DisposeRead()
        {
            if (m_objWorksheet != null)
            {
                Marshal.FinalReleaseComObject(m_objWorksheet);
            }
            if (m_objWorksheetPart != null)
            {
                Marshal.FinalReleaseComObject(m_objWorksheetPart);
            }
            if (m_objWorkbookPart != null)
            {
                Marshal.FinalReleaseComObject(m_objWorkbookPart);
            }
            if (m_objSpreadsheetDocument != null)
            {
                Marshal.FinalReleaseComObject(m_objSpreadsheetDocument);
                int intGeneration = GC.GetGeneration(m_objSpreadsheetDocument);
                m_objSpreadsheetDocument = null;
                GC.Collect(intGeneration);
            }
            GC.Collect();
            GC.Collect();
        }

       
        public List<DataTable> ReadAllSheetToList(Stream stream)
        {
            List<DataTable> tables = new List<DataTable>();

            //MemoryStream ms = new MemoryStream();
            //stream.CopyTo(ms);
            using (SpreadsheetDocument doc = SpreadsheetDocument.Open(stream, false))
            {
                foreach (Sheet sheet in doc.WorkbookPart.Workbook.Descendants<Sheet>())
                {

                    WorksheetPart worksheet = (WorksheetPart)doc.WorkbookPart.GetPartById(sheet.Id);
                    List<string> columnsNames = new List<string>();
                    if (NormalSheets.Contains(sheet.Name.Value))
                    {
                        DataTable table = new DataTable(sheet.Name.Value);
                        foreach (Row row in worksheet.Worksheet.Descendants<Row>())
                        {
                            if (row.RowIndex == BranchCodeRow)
                            {
                                List<string> colvalue = new List<string>();
                                int colindex = 1;
                                int tablecolindex = 1;
                                table.Columns.Add("C" + tablecolindex.ToString());
                                foreach (Cell cell in row)
                                {
                                    tablecolindex++;
                                    if (colindex >= BranchCodeStartCol && !String.IsNullOrEmpty(GetCellValue(doc, cell).ToString().Trim()))
                                    {
                                        table.Columns.Add("C" + tablecolindex.ToString());
                                        colvalue.Add(GetCellValue(doc, cell).ToString().Trim());
                                    }
                                    colindex++;
                                }
                                DataRow dr1 = table.NewRow();
                                dr1[0] = "";
                                for (int i1 = 0; i1 < colvalue.Count; i1++)
                                {
                                    dr1[i1 + 1] = colvalue[i1];
                                }
                                table.Rows.Add(dr1);
                            }
                            else if (row.RowIndex > BranchCodeRow && row.RowIndex <= DataEndRow)
                            {
                                DataRow dr = table.NewRow();
                                int colindex = 1;
                                int readindex = 0;
                                foreach (Cell cell in row)
                                {

                                    if (colindex >= BranchCodeStartCol - 1 && readindex < table.Columns.Count)
                                    {

                                        dr[readindex] = GetCellValue(doc, cell).ToString().Trim();
                                        readindex++;
                                    }
                                    else if (readindex >= table.Columns.Count)
                                    {
                                        break;
                                    }
                                    colindex++;

                                }
                                table.Rows.Add(dr);
                            }
                            else if (row.RowIndex > DataEndRow)
                            {
                                break;
                            }
                        }
                        tables.Add(table);
                    }
                    else if (sheet.Name.Value == "Base")
                    {
                        DataTable table = new DataTable(sheet.Name.Value);
                        table.Columns.Add("c1");



                        foreach (Row row in worksheet.Worksheet.Descendants<Row>())
                        {
                            int colindex = 1;
                            if (row.RowIndex == 2 || row.RowIndex == 3)
                            {
                                foreach (Cell cell in row)
                                {
                                    if (colindex == 2)
                                    {
                                        DataRow dr1 = table.NewRow();
                                        dr1[0] = GetCellValue(doc, cell).ToString().Trim();
                                        table.Rows.Add(dr1);
                                        break;
                                    }
                                    colindex++;

                                }
                                if (row.RowIndex == 3)
                                {
                                    break;
                                }
                            }
                        }
                        tables.Add(table);
                    }
                    else if (sheet.Name.Value == "MO")
                    {

                        DataTable table = new DataTable(sheet.Name.Value);
                        foreach (Row row in worksheet.Worksheet.Descendants<Row>())
                        {

                            if (row.RowIndex == 2)
                            {

                                List<string> colvalue = new List<string>();
                                int colindex = 1;
                                int tablecolindex = 1;
                                table.Columns.Add("C" + tablecolindex.ToString());
                                foreach (Cell cell in row)
                                {

                                    if (colindex >= 3 && !String.IsNullOrEmpty(GetCellValue(doc, cell).ToString().Trim()))
                                    {
                                        tablecolindex++;
                                        table.Columns.Add("C" + tablecolindex.ToString());
                                        colvalue.Add(GetCellValue(doc, cell).ToString().Trim());
                                    }
                                    colindex++;
                                }
                                DataRow dr1 = table.NewRow();
                                dr1[0] = "";
                                for (int i1 = 0; i1 < colvalue.Count; i1++)
                                {
                                    dr1[i1 + 1] = colvalue[i1];
                                }
                                table.Rows.Add(dr1);
                            }
                            else if ((row.RowIndex >= 3 && row.RowIndex <= 7) || (row.RowIndex >= 11 && row.RowIndex <= 15) || (row.RowIndex >= 19 && row.RowIndex <= 23) || (row.RowIndex >= 27 && row.RowIndex <= 31))
                            {
                                DataRow dr = table.NewRow();
                                int colindex = 1;
                                int readindex = 0;
                                foreach (Cell cell in row)
                                {

                                    if (colindex >= 2 && readindex < table.Columns.Count)
                                    {

                                        dr[readindex] = GetCellValue(doc, cell).ToString().Trim();
                                        readindex++;
                                    }
                                    else if (readindex > table.Columns.Count)
                                    {
                                        break;
                                    }
                                    colindex++;

                                }
                                table.Rows.Add(dr);
                            }
                            else if (row.RowIndex > 31)
                            {
                                break;
                            }
                        }
                        tables.Add(table);
                    }
                    else
                    {
                        break;
                    }


                }
            }
            return tables;
        }

        /// <summary>
        /// 将excel中第一个sheet的数据导入到DataTable
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public DataTable ReadFirstSheetData(Stream stream)
        {
            DataTable dt = new DataTable();
            SpreadsheetDocument spreadSheetDocument = SpreadsheetDocument.Open(stream, false);
            WorkbookPart workbookPart = spreadSheetDocument.WorkbookPart;
            IEnumerable<Sheet> sheets = spreadSheetDocument.WorkbookPart.Workbook.GetFirstChild<Sheets>().Elements<Sheet>();
            //string relationshipId = sheets.First().Id.Value = sheets.First(x => x.Name == "Sheet1").Id.Value;
            string relationshipId = sheets.First().Id.Value;
            WorksheetPart worksheetPart = (WorksheetPart)spreadSheetDocument.WorkbookPart.GetPartById(relationshipId);
            Worksheet workSheet = worksheetPart.Worksheet;
            SheetData sheetData = workSheet.GetFirstChild<SheetData>();
            Row[] rows = sheetData.Descendants<Row>().ToArray();
            // Add columns
            foreach (Cell cell in rows.ElementAt(0))
            {
                dt.Columns.Add((string)GetCellValue(spreadSheetDocument, cell));
            }
            // Add rows
            for (int rowIndex = 1; rowIndex < rows.Count(); rowIndex++)
            {
                DataRow tempRow = dt.NewRow();

                for (int i = 0; i < rows[rowIndex].Descendants<Cell>().Count(); i++)
                {
                    tempRow[i] = GetCellValue(spreadSheetDocument, rows[rowIndex].Descendants<Cell>().ElementAt(i));
                }
                dt.Rows.Add(tempRow);
            }
            // Release document
            if (spreadSheetDocument != null)
            {
                int intGeneration = GC.GetGeneration(spreadSheetDocument);
                spreadSheetDocument.Dispose();
                spreadSheetDocument = null;
                GC.Collect(intGeneration);
            }
            return dt;
        }

        private string GetCellValue(SpreadsheetDocument document, Cell cell)
        {
            SharedStringTablePart stringTablePart = document.WorkbookPart.SharedStringTablePart;
            if (cell == null)
            {
                return string.Empty;
            }
            if (cell.CellValue == null)
            {
                return string.Empty;
            }
            string value = cell.CellValue.InnerXml;

            if (cell.DataType != null && (cell.DataType.Value == CellValues.SharedString || cell.DataType.Value == CellValues.String || cell.DataType.Value == CellValues.Number))
            {
                return stringTablePart.SharedStringTable.ChildElements[Int32.Parse(value)].InnerText;
            }
            else  //浮点数和日期对应的cell.DataType都为NULL
            {
                // DateTime.FromOADate((double.Parse(value)); 如果确定是日期就可以直接用过该方法转换为日期对象，可是无法确定DataType==NULL的时候这个CELL 数据到底是浮点型还是日期.(日期被自动转换为浮点
                return value;
            }
        }

      


}

}

 

 

 

呼噜噜哟
关注
专栏目录
OpenXML读写excel方法
12-28
OpenXML读写excel方法，如可以修改格式以及添加值到单元格，仅提供读写Excel的类，只需调用其中方法就可以
Excel文档处理之Open XML
Farmer
07-05 7921
通过Open XML对Excel进行创建、载入、单元格读写、改变单元格样式、添加超链接等。
使用 C# 和 OpenXML 读取大型 Excel 文件
最新发布
技术探索驿站
06-26 1309
高效读取大型 Excel 文件可能具有挑战性，尤其是在处理需要高性能和可扩展性的应用程序时。Microsoft 的 OpenXML SDK 提供了一套强大的工具来处理 Office 文档（包括 Excel 文件），而无需在服务器上安装 Excel。本文将指导您使用 C# 和 OpenXML 高效读取大型 Excel 文件。
Open XML操作Excel——生成Excel、插入文本、删除单元格、插入公式、创建样式
niuge8905的博客
06-03 4836
Open XML 资料 目前发现Open XML的SDK有两个版本，SDK2.0和SDK2.5。 Open XML 2.0的帮助文档：https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/ff478153(v=office.14) Open XML 2.5的帮助文档：https://docs.microsoft.com/zh-cn/office/open-xml/spreadsheets 安装O
使用OpenXML库读取xlsx文档（Excel文档）中的内容
weixinhum
06-24 2343
【代码】使用OpenXML库读取xlsx文档（Excel文档）中的内容。
c# 生成excel文件 OfficeOpenXml
绀目澄清
02-15 4125
【代码】c# 生成excel文件 OfficeOpenXml。
C#使用NOPI库实现导入Excel文档
08-30
在使用NPOI库进行Excel导入时，有几个关键点需要注意： 1. **IWorkbook接口**：这是NPOI中处理Excel工作簿的核心接口。对于.xls文件，你需要使用HSSFWorkbook类来实例化；而对于.xlsx文件，你需要使用XSSFWorkbook...
简单的excel导入导出示例分享
09-04
在本文中，我们将深入探讨如何在.NET环境中进行简单的Excel导入导出操作，特别是在Web应用程序中。Excel文件在数据处理和报告生成中非常常见，因此掌握如何有效地与Excel交互是开发人员的一项基本技能。 首先，标题...
C#开发excel导入导出+mysql数据库
03-20
对于Excel导入，开发者通常需要创建一个数据读取器，遍历Excel文件中的单元格，将数据读取到内存中的数据结构，如DataTable或自定义的类集合。在使用EPPlus时，可以通过`ExcelPackage.LicenseContext = ...
DataTable to Excel File
01-22
以上代码将创建一个名为"output.xlsx"的Excel文件，其中包含从DataTable导入的数据。如果需要自定义样式、设置边框、调整单元格格式等，可以进一步扩展代码。 总结来说，将`DataTable`转换为`Excel`文件，主要依赖...
OpenXML向EXCEL写数据
11-25
利用OpenXML向EXCEL中指定的位置写入字符串或者数据表，己在VS2010开发环境中调试通过
使用Open xml 操作Excel系列之一-读取Excel
weixin_33786077的博客
06-22 1148
一、 安装Open Xml SDK 从微软网站下载Open xml SDK,安装SDK. 二、 在项目中添加对DocumentFormat.OpenXml库的引用 三、 编程读取Excel数据 使用Open Xml 读取Excel的过程中，会遇到许多的Excel概念， 作为一个开发人员，最好能掌握分析这种结构的方法，实际项目中我利用两种方式分析excel文档的结构，一种是直接使...
OpenXML:C#读取Excel文档
地理信息技术杂谈 博客，欢迎技术交流
07-23 4976
Excel的文档，本身就是一个压缩包，使用压缩工具打开一个excel文件，可以看到里边的文件列表如下图： 里边的文件主要就是一些xml文件和其他的素材 OpenXML是微软官方一个开源的操作Word、Excel和PPT的SDK，用C#进行开发，使用此类库可以方便的对office这三类主要文档进行操作，而且还不用安装Office程序。 下边列举一下，如何使用OpenXML读取一个Excel文档中...
C# Net 使用 openxml 写入对象 到 Excel
chinaherolts2008的博客
12-23 1270
C# Net 使用 openxml 写入 对象 到 Excel 中 C# Net 使用openxml写入对象到Excel中 -------------------------文尾看效果--------------------- ----------效果一（模板文件写入集合对象）------ ----------效果二（新建文件写入集合对象）------ 加入包：OpenXml 创建文件：ExcelWrite.cs 复制下面全部代码到文件 ExcelWrite.cs using System; usin
OpenXml 操作Excel，Word，PPT
jakkiejinn的博客
12-08 1125
转载自线上数据建模 (allmlp.com) OpenXml 可以在不用打开Excel，Word和PPT的情况下，对其进行操作。 我们知道Excel，PPT和word可以通过对其进行解压，发现所有的数据都是保存在xml里的，如下图所示，因此我们可以通过编译XML来获取其中的数据。
C# 导出导出操作Excel的6种方法实现
热门推荐
爱折腾的博客
11-18 1万+
Microsoft.Office.Interop.Excel是一个Microsoft.Office.Interop程序集，它提供一个C# API来编写Excel文件。与Microsoft.Office.Interop.Excel和NPOI相比，EPPlus提供了更好的性能和更容易使用的API。Aspose.Cells是一个商业级的Excel类库，它提供了一组用于处理Excel文件的高级API。与Microsoft.Office.Interop.Excel相比，NPOI提供了更好的性能和更容易使用的API。
ClosedXML、DocumentFormat.OpenXml导出DataTable到Excel
zhoumouren88的博客
04-19 665
在很多系统中都用到导出，使用过多种导出方式，觉得ClosedXML插件的导出简单又方便。 并且ClosedXML、DocumentFormat.OpenXml都是MIT开源。 首先通过 Nuget 安装 ClosedXML 插件，同时会自动安装 DocumentFormat.OpenXml 插件。 以下就是导出相关的代码： 1、MVC控制器中的导出 // MVC 控制器中 /// <summary> /// 导出 （无论是否需要返回值，都有 Response） /// </summar.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值