[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 = 0;
            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 = 0;
            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 + 1); i <= sheet.LastRowNum; i++)
            {
                IRow row = sheet.GetRow(i);
                //如果遇到某行的第一个单元格的值为空，则不再继续向下读取
                if (row != null && !string.IsNullOrEmpty(row.GetCell(0).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 = 0; i < sourceDs.Tables.Count; i++)
            {
                DataTable table = sourceDs.Tables[i];
                string sheetName = "result" + i.ToString();
                ISheet sheet = workbook.CreateSheet(sheetName);
                IRow headerRow = sheet.CreateRow(0);
                // 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 = 1;
 
                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 <= 0) 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(0);
            // 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 = 1;
 
            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 <= 0) 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(0);
 
            for (int i = 0; i < headerNameList.Count; i++)
            {
                ICell cell = headerRow.CreateCell(i);
                cell.SetCellValue(headerNameList[i].Value);
                cell.CellStyle = cellStyle;
            }
 
            Type t = typeof(T);
            int rowIndex = 1;
            foreach (T item in data)
            {
                IRow dataRow = sheet.CreateRow(rowIndex);
                for (int n = 0; 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 <= 0) 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(0);
 
            for (int i = 0; i < grid.Columns.Count; i++)
            {
                ICell cell = headerRow.CreateCell(i);
                cell.SetCellValue(grid.Columns[i].HeaderText);
                cell.CellStyle = cellStyle;
            }
 
            int rowIndex = 1;
            foreach (DataGridViewRow row in grid.Rows)
            {
                IRow dataRow = sheet.CreateRow(rowIndex);
                for (int n = 0; 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 = -1;
            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 = 0; 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 + 1;
            int system = 26;
            char[] digArray = new char[100];
            int i = 0;
            while (index > 0)
            {
                int mod = index % system;
                if (mod == 0) mod = system;
                digArray[i++] = (char)(mod - 1 + 'A');
                index = (index - 1) / 26;
            }
            StringBuilder sb = new StringBuilder(i);
            for (int j = i - 1; j >= 0; 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[2]);
                int month = Convert.ToInt32(time[0]);
                int day = Convert.ToInt32(time[1]);
                string years = Convert.ToString(year);
                string months = Convert.ToString(month);
                string days = Convert.ToString(day);
                if (months.Length == 4)
                {
                    dt = Convert.ToDateTime(date);
                }
                else
                {
                    string rq = "";
                    if (years.Length == 1)
                    {
                        years = "0" + years;
                    }
                    if (months.Length == 1)
                    {
                        months = "0" + months;
                    }
                    if (days.Length == 1)
                    {
                        days = "0" + days;
                    }
                    rq = "20" + 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 = 0;
            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=="0" || bStr=="1")
            {
                return (bStr == "0");
            }
            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, 0, 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的组件  大家可以根据自己的需求来选择合适的开发方式。

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