[Asp.net] C# 操作Excel的几种方式 优缺点比较

在项目中我们常常需要将数据库中的数据导出成Excel文件

有一次工作中我的目的就是读取Excel到内存中，整理成指定格式 整理后再导出到Excel。

因为我要处理的每个Excel表格文件很大。一个表格多个sheet，每个sheet-一千到上W行不等。列数超过300列。

所有在这里我将在使用一些处理Excel的方法的时候，所遇到的一些问题记录下来，也做一个大致的比较。主要是针对此次数据处理

NPOI

目前比较流行的一款操作Excel的组件。移植于Java的POI，是一个开源项目，对Excel的操作很全面。

官网 https://github.com/tonyqus/npoi

优势：

1、免费

2、机器不用安装Office也可以直接操作Excel，免去很多事。

3、现在已至此的文件格式包括Excel2003和2007之后的xls，xlsx以及docx。

4、支持文件的导入和导出

5、网上有丰富的实例代码，遇到基本的问题可以上网参考网友的解决方法。

6、NPOI能支持绝大多数Excel里面的功能操作(Excel内的公式函数、设置单元格的格式样式)

7、导入导出速度快。内存占用大。

特定优势：

支持读取超过256列的Excel表格。

缺点：

参考目前很多网上的文档，npoi导出xlsx，使用 XSSFWorkbook 使用 Write 方法写入内存流后，返回的 MemoryStream 已经被关闭了，不能再使用了。

你需要花一点时间解决这个问题。

可以参考：http://www.holdcode.com/server/details/127

xlsx格式导出 推荐使用Epplus组件

NPOI辅助类：

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 using System.IO;
 using System.Data;
 using System.Windows.Forms;
 using NPOI.SS.UserModel;
 using NPOI.HSSF.UserModel;
 using NPOI.XSSF.UserModel;

 namespace TEMS.Service
 {
     public static class ExcelHelperForCs
     {
         #region 私有方法

         /// <summary>
         /// 获取要保存的文件名称（含完整路径）
         /// </summary>
         /// <returns></returns>
         private static string GetSaveFilePath()
         {
             SaveFileDialog saveFileDig = new SaveFileDialog();
             saveFileDig.Filter = "Excel Office97-2003(*.xls)|*.xls|Excel Office2007及以上(*.xlsx)|*.xlsx";
             saveFileDig.FilterIndex = ;
             saveFileDig.Title = "导出到";
             saveFileDig.OverwritePrompt = true;
             saveFileDig.InitialDirectory = Common.DesktopDirectory;
             string filePath = null;
             if (saveFileDig.ShowDialog() == DialogResult.OK)
             {
                 filePath = saveFileDig.FileName;
             }

             return filePath;
         }

         /// <summary>
         /// 获取要打开要导入的文件名称（含完整路径）
         /// </summary>
         /// <returns></returns>
         private static string GetOpenFilePath()
         {
             OpenFileDialog openFileDig = new OpenFileDialog();
             openFileDig.Filter = "Excel Office97-2003(*.xls)|*.xls|Excel Office2007及以上(*.xlsx)|*.xlsx";
             openFileDig.FilterIndex = ;
             openFileDig.Title = "打开";
             openFileDig.CheckFileExists = true;
             openFileDig.CheckPathExists = true;
             openFileDig.InitialDirectory = Common.DesktopDirectory;
             string filePath = null;
             if (openFileDig.ShowDialog() == DialogResult.OK)
             {
                 filePath = openFileDig.FileName;
             }

             return filePath;
         }

         /// <summary>
         /// 判断是否为兼容模式
         /// </summary>
         /// <param name="filePath"></param>
         /// <returns></returns>
         private static bool GetIsCompatible(string filePath)
         {
             return filePath.EndsWith(".xls", StringComparison.OrdinalIgnoreCase);
         }

         /// <summary>
         /// 创建工作薄
         /// </summary>
         /// <param name="isCompatible"></param>
         /// <returns></returns>
         private static IWorkbook CreateWorkbook(bool isCompatible)
         {
             if (isCompatible)
             {
                 return new HSSFWorkbook();
             }
             else
             {
                 return new XSSFWorkbook();
             }
         }

         /// <summary>
         /// 创建工作薄(依据文件流)
         /// </summary>
         /// <param name="isCompatible"></param>
         /// <param name="stream"></param>
         /// <returns></returns>
         private static IWorkbook CreateWorkbook(bool isCompatible, dynamic stream)
         {
             if (isCompatible)
             {
                 return new HSSFWorkbook(stream);
             }
             else
             {
                 return new XSSFWorkbook(stream);
             }
         }

         /// <summary>
         /// 创建表格头单元格
         /// </summary>
         /// <param name="sheet"></param>
         /// <returns></returns>
         private static ICellStyle GetCellStyle(IWorkbook workbook)
         {
             ICellStyle style = workbook.CreateCellStyle();
             style.FillPattern = FillPattern.SolidForeground;
             style.FillForegroundColor = NPOI.HSSF.Util.HSSFColor.Grey25Percent.Index;

             return style;
         }

         /// <summary>
         /// 从工作表中生成DataTable
         /// </summary>
         /// <param name="sheet"></param>
         /// <param name="headerRowIndex"></param>
         /// <returns></returns>
         private static DataTable GetDataTableFromSheet(ISheet sheet, int headerRowIndex)
         {
             DataTable table = new DataTable();

             IRow headerRow = sheet.GetRow(headerRowIndex);
             int cellCount = headerRow.LastCellNum;

             for (int i = headerRow.FirstCellNum; i < cellCount; i++)
             {
                 if (headerRow.GetCell(i) == null || headerRow.GetCell(i).StringCellValue.Trim() == "")
                 {
                     // 如果遇到第一个空列，则不再继续向后读取
                     cellCount = i;
                     break;
                 }
                 DataColumn column = new DataColumn(headerRow.GetCell(i).StringCellValue);
                 table.Columns.Add(column);
             }

             for (int i = (headerRowIndex + ); i <= sheet.LastRowNum; i++)
             {
                 IRow row = sheet.GetRow(i);
                 //如果遇到某行的第一个单元格的值为空，则不再继续向下读取
                 if (row != null && !string.IsNullOrEmpty(row.GetCell().ToString()))
                 {
                     DataRow dataRow = table.NewRow();

                     for (int j = row.FirstCellNum; j < cellCount; j++)
                     {
                         dataRow[j] = row.GetCell(j).ToString();
                     }

                     table.Rows.Add(dataRow);
                 }
             }

             return table;
         }

         #endregion

         #region 公共导出方法

         /// <summary>
         /// 由DataSet导出Excel
         /// </summary>
         /// <param name="sourceTable">要导出数据的DataTable</param>
         /// <returns>Excel工作表</returns>
         public static string ExportToExcel(DataSet sourceDs, string filePath = null)
         {

             if (string.IsNullOrEmpty(filePath))
             {
                 filePath = GetSaveFilePath();
             }

             if (string.IsNullOrEmpty(filePath)) return null;

             bool isCompatible = GetIsCompatible(filePath);

             IWorkbook workbook = CreateWorkbook(isCompatible);
             ICellStyle cellStyle = GetCellStyle(workbook);

             for (int i = ; i < sourceDs.Tables.Count; i++)
             {
                 DataTable table = sourceDs.Tables[i];
                 string sheetName = "result" + i.ToString();
                 ISheet sheet = workbook.CreateSheet(sheetName);
                 IRow headerRow = sheet.CreateRow();
                 // handling header.
                 foreach (DataColumn column in table.Columns)
                 {
                     ICell cell = headerRow.CreateCell(column.Ordinal);
                     cell.SetCellValue(column.ColumnName);
                     cell.CellStyle = cellStyle;
                 }

                 // handling value.
                 int rowIndex = ;

                 foreach (DataRow row in table.Rows)
                 {
                     IRow dataRow = sheet.CreateRow(rowIndex);

                     foreach (DataColumn column in table.Columns)
                     {
                         dataRow.CreateCell(column.Ordinal).SetCellValue((row[column] ?? "").ToString());
                     }

                     rowIndex++;
                 }
             }

             FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
             workbook.Write(fs);
             fs.Dispose();
             workbook = null;

             return filePath;

         }

         /// <summary>
         /// 由DataTable导出Excel
         /// </summary>
         /// <param name="sourceTable">要导出数据的DataTable</param>
         /// <returns>Excel工作表</returns>
         public static string ExportToExcel(DataTable sourceTable, string sheetName = "result", string filePath = null)
         {
             if (sourceTable.Rows.Count <= ) return null;

             if (string.IsNullOrEmpty(filePath))
             {
                 filePath = GetSaveFilePath();
             }

             if (string.IsNullOrEmpty(filePath)) return null;

             bool isCompatible = GetIsCompatible(filePath);

             IWorkbook workbook = CreateWorkbook(isCompatible);
             ICellStyle cellStyle = GetCellStyle(workbook);

             ISheet sheet = workbook.CreateSheet(sheetName);
             IRow headerRow = sheet.CreateRow();
             // handling header.
             foreach (DataColumn column in sourceTable.Columns)
             {
                 ICell headerCell = headerRow.CreateCell(column.Ordinal);
                 headerCell.SetCellValue(column.ColumnName);
                 headerCell.CellStyle = cellStyle;
             }

             // handling value.
             int rowIndex = ;

             foreach (DataRow row in sourceTable.Rows)
             {
                 IRow dataRow = sheet.CreateRow(rowIndex);

                 foreach (DataColumn column in sourceTable.Columns)
                 {
                     dataRow.CreateCell(column.Ordinal).SetCellValue((row[column]??"").ToString());
                 }

                 rowIndex++;
             }
             FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
             workbook.Write(fs);
             fs.Dispose();

             sheet = null;
             headerRow = null;
             workbook = null;

             return filePath;
         }

         /// <summary>
         /// 由List导出Excel
         /// </summary>
         /// <typeparam name="T">类型</typeparam>
         /// <param name="data">在导出的List</param>
         /// <param name="sheetName">sheet名称</param>
         /// <returns></returns>
         public static string ExportToExcel<T>(List<T> data, IList<KeyValuePair<string, string>> headerNameList, string sheetName = "result", string filePath = null) where T : class
         {
             if (data.Count <= ) return null;

             if (string.IsNullOrEmpty(filePath))
             {
                 filePath = GetSaveFilePath();
             }

             if (string.IsNullOrEmpty(filePath)) return null;

             bool isCompatible = GetIsCompatible(filePath);

             IWorkbook workbook = CreateWorkbook(isCompatible);
             ICellStyle cellStyle = GetCellStyle(workbook);
             ISheet sheet = workbook.CreateSheet(sheetName);
             IRow headerRow = sheet.CreateRow();

             for (int i = ; i < headerNameList.Count; i++)
             {
                 ICell cell = headerRow.CreateCell(i);
                 cell.SetCellValue(headerNameList[i].Value);
                 cell.CellStyle = cellStyle;
             }

             Type t = typeof(T);
             int rowIndex = ;
             foreach (T item in data)
             {
                 IRow dataRow = sheet.CreateRow(rowIndex);
                 for (int n = ; n < headerNameList.Count; n++)
                 {
                     object pValue = t.GetProperty(headerNameList[n].Key).GetValue(item, null);
                     dataRow.CreateCell(n).SetCellValue((pValue ?? "").ToString());
                 }
                 rowIndex++;
             }
             FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
             workbook.Write(fs);
             fs.Dispose();

             sheet = null;
             headerRow = null;
             workbook = null;

             return filePath;
         }

         /// <summary>
         /// 由DataGridView导出
         /// </summary>
         /// <param name="grid"></param>
         /// <param name="sheetName"></param>
         /// <param name="filePath"></param>
         /// <returns></returns>
         public static string ExportToExcel(DataGridView grid, string sheetName = "result", string filePath = null)
         {
             if (grid.Rows.Count <= ) return null;

             if (string.IsNullOrEmpty(filePath))
             {
                 filePath = GetSaveFilePath();
             }

             if (string.IsNullOrEmpty(filePath)) return null;

             bool isCompatible = GetIsCompatible(filePath);

             IWorkbook workbook = CreateWorkbook(isCompatible);
             ICellStyle cellStyle = GetCellStyle(workbook);
             ISheet sheet = workbook.CreateSheet(sheetName);

             IRow headerRow = sheet.CreateRow();

             for (int i = ; i < grid.Columns.Count; i++)
             {
                 ICell cell = headerRow.CreateCell(i);
                 cell.SetCellValue(grid.Columns[i].HeaderText);
                 cell.CellStyle = cellStyle;
             }

             int rowIndex = ;
             foreach (DataGridViewRow row in grid.Rows)
             {
                 IRow dataRow = sheet.CreateRow(rowIndex);
                 for (int n = ; n < grid.Columns.Count; n++)
                 {
                     dataRow.CreateCell(n).SetCellValue((row.Cells[n].Value ?? "").ToString());
                 }
                 rowIndex++;
             }

             FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
             workbook.Write(fs);
             fs.Dispose();

             sheet = null;
             headerRow = null;
             workbook = null;

             return filePath;
         }

         #endregion

         #region 公共导入方法

         /// <summary>
         /// 由Excel导入DataTable
         /// </summary>
         /// <param name="excelFileStream">Excel文件流</param>
         /// <param name="sheetName">Excel工作表名称</param>
         /// <param name="headerRowIndex">Excel表头行索引</param>
         /// <param name="isCompatible">是否为兼容模式</param>
         /// <returns>DataTable</returns>
         public static DataTable ImportFromExcel(Stream excelFileStream, string sheetName, int headerRowIndex, bool isCompatible)
         {
             IWorkbook workbook = CreateWorkbook(isCompatible, excelFileStream);
             ISheet sheet = null;
             int sheetIndex = -;
             if (int.TryParse(sheetName, out sheetIndex))
             {
                 sheet = workbook.GetSheetAt(sheetIndex);
             }
             else
             {
                 sheet = workbook.GetSheet(sheetName);
             }

             DataTable table = GetDataTableFromSheet(sheet, headerRowIndex);

             excelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         /// <summary>
         /// 由Excel导入DataTable
         /// </summary>
         /// <param name="excelFilePath">Excel文件路径，为物理路径。</param>
         /// <param name="sheetName">Excel工作表名称</param>
         /// <param name="headerRowIndex">Excel表头行索引</param>
         /// <returns>DataTable</returns>
         public static DataTable ImportFromExcel(string excelFilePath, string sheetName, int headerRowIndex)
         {
             if (string.IsNullOrEmpty(excelFilePath))
             {
                 excelFilePath = GetOpenFilePath();
             }

             if (string.IsNullOrEmpty(excelFilePath))
             {
                 return null;
             }

             using (FileStream stream = System.IO.File.OpenRead(excelFilePath))
             {
                 bool isCompatible = GetIsCompatible(excelFilePath);
                 return ImportFromExcel(stream, sheetName, headerRowIndex, isCompatible);
             }
         }

         /// <summary>
         /// 由Excel导入DataSet，如果有多个工作表，则导入多个DataTable
         /// </summary>
         /// <param name="excelFileStream">Excel文件流</param>
         /// <param name="headerRowIndex">Excel表头行索引</param>
         /// <param name="isCompatible">是否为兼容模式</param>
         /// <returns>DataSet</returns>
         public static DataSet ImportFromExcel(Stream excelFileStream, int headerRowIndex, bool isCompatible)
         {
             DataSet ds = new DataSet();
             IWorkbook workbook = CreateWorkbook(isCompatible, excelFileStream);
             for (int i = ; i < workbook.NumberOfSheets; i++)
             {
                 ISheet sheet = workbook.GetSheetAt(i);
                 DataTable table = GetDataTableFromSheet(sheet, headerRowIndex);
                 ds.Tables.Add(table);
             }

             excelFileStream.Close();
             workbook = null;

             return ds;
         }

         /// <summary>
         /// 由Excel导入DataSet，如果有多个工作表，则导入多个DataTable
         /// </summary>
         /// <param name="excelFilePath">Excel文件路径，为物理路径。</param>
         /// <param name="headerRowIndex">Excel表头行索引</param>
         /// <returns>DataSet</returns>
         public static DataSet ImportFromExcel(string excelFilePath, int headerRowIndex)
         {
             if (string.IsNullOrEmpty(excelFilePath))
             {
                 excelFilePath = GetOpenFilePath();
             }

             if (string.IsNullOrEmpty(excelFilePath))
             {
                 return null;
             }

             using (FileStream stream = System.IO.File.OpenRead(excelFilePath))
             {
                 bool isCompatible = GetIsCompatible(excelFilePath);
                 return ImportFromExcel(stream, headerRowIndex, isCompatible);
             }
         }

         #endregion

         #region 公共转换方法

         /// <summary>
         /// 将Excel的列索引转换为列名，列索引从0开始，列名从A开始。如第0列为A，第1列为B...
         /// </summary>
         /// <param name="index">列索引</param>
         /// <returns>列名，如第0列为A，第1列为B...</returns>
         public static string ConvertColumnIndexToColumnName(int index)
         {
             index = index + ;
             int system = ;
             char[] digArray = new char[];
             int i = ;
             while (index > )
             {
                 int mod = index % system;
                 if (mod == ) mod = system;
                 digArray[i++] = (char)(mod -  + 'A');
                 index = (index - ) / ;
             }
             StringBuilder sb = new StringBuilder(i);
             for (int j = i - ; j >= ; j--)
             {
                 sb.Append(digArray[j]);
             }
             return sb.ToString();
         }

         /// <summary>
         /// 转化日期
         /// </summary>
         /// <param name="date">日期</param>
         /// <returns></returns>
         public static DateTime ConvertToDate(object date)
         {
             string dtStr = (date ?? "").ToString();

             DateTime dt = new DateTime();

             if (DateTime.TryParse(dtStr, out dt))
             {
                 return dt;
             }

             try
             {
                 string spStr = "";
                 if (dtStr.Contains("-"))
                 {
                     spStr = "-";
                 }
                 else if (dtStr.Contains("/"))
                 {
                     spStr = "/";
                 }
                 string[] time = dtStr.Split(spStr.ToCharArray());
                 int year = Convert.ToInt32(time[]);
                 int month = Convert.ToInt32(time[]);
                 int day = Convert.ToInt32(time[]);
                 string years = Convert.ToString(year);
                 string months = Convert.ToString(month);
                 string days = Convert.ToString(day);
                 if (months.Length == )
                 {
                     dt = Convert.ToDateTime(date);
                 }
                 else
                 {
                     string rq = "";
                     if (years.Length == )
                     {
                         years = "" + years;
                     }
                     if (months.Length == )
                     {
                         months = "" + months;
                     }
                     if (days.Length == )
                     {
                         days = "" + days;
                     }
                     rq = "" + years + "-" + months + "-" + days;
                     dt = Convert.ToDateTime(rq);
                 }
             }
             catch
             {
                 throw new Exception("日期格式不正确，转换日期类型失败！");
             }
             return dt;
         }

         /// <summary>
         /// 转化数字
         /// </summary>
         /// <param name="d">数字字符串</param>
         /// <returns></returns>
         public static decimal ConvertToDecimal(object d)
         {
             string dStr = (d ?? "").ToString();
             decimal result = ;
             if (decimal.TryParse(dStr, out result))
             {
                 return result;
             }
             else
             {
                 throw new Exception("数字格式不正确，转换数字类型失败！");
             }

         }

         /// <summary>
         /// 转化布尔
         /// </summary>
         /// <param name="b"></param>
         /// <returns></returns>
         public static bool ConvertToBoolen(object b)
         {
             string bStr = (b ?? "").ToString().Trim();
             bool result = false;
             if (bool.TryParse(bStr, out result))
             {
                 return result;
             }
             else if (bStr=="" || bStr=="")
             {
                 return (bStr == "");
             }
             else
             {
                 throw new Exception("布尔格式不正确，转换布尔类型失败！");
             }
         }

         #endregion
     }
 }

遇见蓝匣子

c#中NPOI处理excel中的各种类型

 ICell cell = row.GetCell(i);
     if (cell.CellType == CellType.NUMERIC)
     {
         //NPOI中数字和日期都是NUMERIC类型的，这里对其进行判断是否是日期类型
         if (HSSFDateUtil.IsCellDateFormatted(cell))//日期类型
         {
             dataRow[i] = cell.DateCellValue;
         }
         else//其他数字类型
         {
             dataRow[i] = cell.NumericCellValue;
         }
     }
     else if (cell.CellType == CellType.BLANK)//空数据类型
     {
         dataRow[i] = "";
     }
     else if (cell.CellType == CellType.FORMULA)//公式类型
     {
         HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(workbook);
         dataRow[i] = eva.Evaluate(cell).StringValue;
     }
     else //其他类型都按字符串类型来处理
     {
         dataRow[i] = cell.StringCellValue;
     }

使用方法参考链接：

https://www.cnblogs.com/5tao/p/4302540.html

http://www.cnblogs.com/restran/p/3889479.html

http://blog.csdn.net/dcrmg/article/details/52356236

OLEDB

使用Microsoft Jet 提供程序用于连接到 Excel 工作簿,将Excel文件作为数据源来读写

优点：

简单快速,能够操作高版本Excel，占用内存很少。

缺点：

不灵活，只能够进行有限的操作(读、写)

特定缺点：读取列最多只能读取到255列。

使用参考链接：

https://www.cnblogs.com/ammy714926/p/4905026.html

http://blog.csdn.net/zzq900503/article/details/8802855

https://www.ctolib.com/topics-52087.html

COM组件

利用office的com组件对Excel进行操作。

有人在使用com组件的时候发现效率很低，其实是使用不当导致的，COM来操作Excel的朋友可以用数组的方式来操作读写。效率提升很大

优点：

操作excel多一种选择（相比较NPOI缺点更突出）

明显缺点：

要求本机安装了Microsoft Office组件。

代码复杂不易理解。
在操作中需要处理大量的数据类型。

使用方法参考链接：

https://www.cnblogs.com/daviddai/archive/2013/06/10/Excel.html

EPPlus

官网：https://epplus.codeplex.com/

Epplus是一个使用Open Office XML文件格式，能读写Excel2007/2010文件的开源组件，在导出Excel的时候不需要电脑上安装office。

优点：

不需要安装office

Epplus另一个出色的地方就是支持图表的列印

导入导出速度快，支持高版本Excel格式，Epplus可以实现Excel上的各种基本功能

唯一缺点：

不支持导出2003版Excel

导出Excel(xlsx)辅助类

        /// <summary>
        /// 使用EPPlus导出Excel(xlsx)
        /// </summary>
        /// <param name="sourceTable">数据源</param>
        /// <param name="strFileName">xlsx文件名(不含后缀名)</param>
        /// <param name="saveFilePath">保存文件路径</param>
        /// <param name="isOpen"></param>
        public static void ExportByEPPlus(DataTable sourceTable, string strFileName, string saveFilePath)
        {
            try
            {
                using (ExcelPackage pck = new ExcelPackage())
                {
                    //创建工作簿
                    string sheetName = string.IsNullOrEmpty(sourceTable.TableName) ? "Sheet1" : sourceTable.TableName;
                    using (ExcelWorksheet ws = pck.Workbook.Worksheets.Add(sheetName))
                    {
                        //从第一行加载表格
                        ws.Cells["A1"].LoadFromDataTable(sourceTable, true);
                        //写入文件
                        string saveFullPath = saveFilePath + "\\" + strFileName + ".xlsx";
                        using (FileStream fs = new FileStream(saveFullPath, FileMode.Create, FileAccess.Write))
                        {
                            byte[] data = pck.GetAsByteArray();
                            fs.Write(data, , data.Length);
                            fs.Flush();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

使用方式参考链接：

https://www.idaima.com/article/2837

https://www.cnblogs.com/dzw2017/p/6663714.html

Aspose.Cell

官网：https://zh.aspose.com/products/cells/net

优点：

不需要安装office

和NPOI一样有团队一直在更新，维护，支持的操作非常多。

控件功能非常强大：支持多种参数变量的绑定操作，如支持DataSet、Datatable、IList集合，实体类集合、类对象等。

多种格式的转换，将Excel文件转换成PDF格式，打开加密的excel，

缺点：

收费

可参考的资料较少

使用方式参考链接：

https://www.cnblogs.com/wuhuacong/archive/2011/02/23/1962147.html

https://www.cnblogs.com/kenblove/archive/2009/01/07/1371104.html

以上就是我接触到的几款c# 操作Excel的组件  大家可以根据自己的需求来选择合适的开发方式。

有不对的地方欢迎斧正。谢谢