导入导出Excel

最近需要频繁的使用导入导出，各么，又不想使用ms的PIA，在4.0以下，存在版本兼容的问题。

于是网上查找了很久，找到两款开源的excel组件。

1、CSharpJExcel，这是JExcel的.net版本，但是只支持到2003，也就是xls格式。

2、NPOI，这是一款国人写的开源组件，功能挺好，就是代码看着有点乱~尤其是xlsx段。优点在于demo比较详细

不管如何，先用了再说。

贴一段改过的helper类

 /*******************************************************************
  * 版权所有：
  * 类 名 称：ExcelHelper
  * 作    者：zk
  * 电子邮箱：77148918@QQ.com
  * 创建日期：2012/2/25 10:17:21
  * 修改描述：从excel导入datatable时，可以导入日期类型。
  *           但对excel中的日期类型有一定要求，要求至少是yyyy/mm/dd类型日期； *
  * 修改描述：将datatable导入excel中，对类型为字符串的数字进行处理，
  *           导出数字为double类型；
  * 修改描述：针对NPOI 2.0 alpha版本更新，修改了导入excel的方法，划分为2003版本和2007版本；
  *           将导入方法里的HSSFWorkbook改为接口；
  *           将 NPOI.HSSF.UserModel.HSSFRow改为了NPOI.XSSF.UserModel.XSSFRow(只存在导入excel2007的方法中）
  *           将 导入方法的参数HSSFSheet sheet改为了接口类型ISheet（2003的导入方法和2007均有修改）
  *           将 导入方法区分为导入Excel2003以及导入Excel2007；
  * 修改日期：2012年5月4日22:06:29 for Jnz Update to NPOI 1.25 正式版
  * 修改日期：2012年8月30日17:13:49 for Jnz Update to NPOI 2.0 alpha版
  * 修改日期：2015年9月7日  for Feedback Update to NPOI 2.1.3.1 Stable版
  *
  * *******************************************************************/
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.IO;
 using System.Text;
 using System.Web;
 using NPOI;
 using NPOI.HPSF;
 using NPOI.HSSF;
 using NPOI.HSSF.Record;//NPOI.HSSF.Record.Formula.Eval改为了NPOI.SS.Formula.Eval;
 using NPOI.SS.Formula.Eval;//同上
 using NPOI.HSSF.UserModel;
 using NPOI.HSSF.Util;
 using NPOI.POIFS;
 using NPOI.SS.UserModel;
 using NPOI.Util;
 using NPOI.SS;
 using NPOI.DDF;
 using NPOI.SS.Util;
 using NPOI.XSSF.UserModel;//
 using System.Collections;
 using System.Text.RegularExpressions;

 namespace XX.Carto
 {
     public class ExcelHelper
     {
         //private static WriteLog wl = new WriteLog();

         #region 从datatable中将数据导出到excel
         /// <summary>
         /// DataTable导出到Excel的MemoryStream
         /// </summary>
         /// <param name="dtSource">源DataTable</param>
         /// <param name="strHeaderText">表头文本</param>
         static MemoryStream ExportDT(DataTable dtSource, string strHeaderText)
         {
             HSSFWorkbook workbook = new HSSFWorkbook();
             HSSFSheet sheet = workbook.CreateSheet() as HSSFSheet;

             #region 右击文件 属性信息

             //{
             //    DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
             //    dsi.Company = "http://www.yongfa365.com/";
             //    workbook.DocumentSummaryInformation = dsi;

             //    SummaryInformation si = PropertySetFactory.CreateSummaryInformation();
             //    si.Author = "柳永法"; //填加xls文件作者信息
             //    si.ApplicationName = "NPOI测试程序"; //填加xls文件创建程序信息
             //    si.LastAuthor = "柳永法2"; //填加xls文件最后保存者信息
             //    si.Comments = "说明信息"; //填加xls文件作者信息
             //    si.Title = "NPOI测试"; //填加xls文件标题信息
             //    si.Subject = "NPOI测试Demo"; //填加文件主题信息
             //    si.CreateDateTime = DateTime.Now;
             //    workbook.SummaryInformation = si;
             //}

             #endregion

             HSSFCellStyle dateStyle = workbook.CreateCellStyle() as HSSFCellStyle;
             HSSFDataFormat format = workbook.CreateDataFormat() as HSSFDataFormat;
             dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");

             //取得列宽
             int[] arrColWidth = new int[dtSource.Columns.Count];
             foreach (DataColumn item in dtSource.Columns)
             {
                 arrColWidth[item.Ordinal] = Encoding.GetEncoding().GetBytes(item.ColumnName.ToString()).Length;
             }
             for (int i = ; i < dtSource.Rows.Count; i++)
             {
                 for (int j = ; j < dtSource.Columns.Count; j++)
                 {
                     int intTemp = Encoding.GetEncoding().GetBytes(dtSource.Rows[i][j].ToString()).Length;
                     if (intTemp > arrColWidth[j])
                     {
                         arrColWidth[j] = intTemp;
                     }
                 }
             }
             int rowIndex = ;

             foreach (DataRow row in dtSource.Rows)
             {
                 #region 新建表，填充表头，填充列头，样式

                 if (rowIndex ==  || rowIndex == )
                 {
                     if (rowIndex != )
                     {
                         sheet = workbook.CreateSheet() as HSSFSheet;
                     }

                     #region 表头及样式

                     {
                         HSSFRow headerRow = sheet.CreateRow() as HSSFRow;
                         headerRow.HeightInPoints = ;
                         headerRow.CreateCell().SetCellValue(strHeaderText);

                         HSSFCellStyle headStyle = workbook.CreateCellStyle() as HSSFCellStyle;
                         headStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
                         HSSFFont font = workbook.CreateFont() as HSSFFont;
                         font.FontHeightInPoints = ;
                         font.Boldweight = ;
                         headStyle.SetFont(font);

                         headerRow.GetCell().CellStyle = headStyle;

                         //sheet.AddMergedRegion(new Region(0, 0, 0, dtSource.Columns.Count - 1));方法已过时
                         sheet.AddMergedRegion(new CellRangeAddress(, , , dtSource.Columns.Count - ));//2015-09-07 by feedback
                         //headerRow.Dispose();
                     }

                     #endregion

                     #region 列头及样式

                     {
                         HSSFRow headerRow = sheet.CreateRow() as HSSFRow;

                         HSSFCellStyle headStyle = workbook.CreateCellStyle() as HSSFCellStyle;
                         headStyle.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
                         HSSFFont font = workbook.CreateFont() as HSSFFont;
                         font.FontHeightInPoints = ;
                         font.Boldweight = ;
                         headStyle.SetFont(font);

                         foreach (DataColumn column in dtSource.Columns)
                         {
                             headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
                             headerRow.GetCell(column.Ordinal).CellStyle = headStyle;

                             //设置列宽
                             sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + ) * );

                         }
                         //headerRow.Dispose();
                     }

                     #endregion

                     rowIndex = ;
                 }

                 #endregion

                 #region 填充内容

                 HSSFRow dataRow = sheet.CreateRow(rowIndex) as HSSFRow;
                 foreach (DataColumn column in dtSource.Columns)
                 {
                     HSSFCell newCell = dataRow.CreateCell(column.Ordinal) as HSSFCell;

                     string drValue = row[column].ToString();

                     switch (column.DataType.ToString())
                     {
                         case "System.String": //字符串类型
                             double result;
                             if (isNumeric(drValue, out result))
                             {

                                 double.TryParse(drValue, out result);
                                 newCell.SetCellValue(result);
                                 break;
                             }
                             else
                             {
                                 newCell.SetCellValue(drValue);
                                 break;
                             }

                         case "System.DateTime": //日期类型
                             DateTime dateV;
                             DateTime.TryParse(drValue, out dateV);
                             newCell.SetCellValue(dateV);

                             newCell.CellStyle = dateStyle; //格式化显示
                             break;
                         case "System.Boolean": //布尔型
                             bool boolV = false;
                             bool.TryParse(drValue, out boolV);
                             newCell.SetCellValue(boolV);
                             break;
                         case "System.Int16": //整型
                         case "System.Int32":
                         case "System.Int64":
                         case "System.Byte":
                             int intV = ;
                             int.TryParse(drValue, out intV);
                             newCell.SetCellValue(intV);
                             break;
                         case "System.Decimal": //浮点型
                         case "System.Double":
                             double doubV = ;
                             double.TryParse(drValue, out doubV);
                             newCell.SetCellValue(doubV);
                             break;
                         case "System.DBNull": //空值处理
                             newCell.SetCellValue("");
                             break;
                         default:
                             newCell.SetCellValue("");
                             break;
                     }

                 }

                 #endregion

                 rowIndex++;
             }
             using (MemoryStream ms = new MemoryStream())
             {
                 workbook.Write(ms);
                 ms.Flush();
                 ms.Position = ;

                 //sheet;
                 //workbook.Dispose();

                 return ms;
             }
         }

         /// <summary>
         /// DataTable导出到Excel文件
         /// </summary>
         /// <param name="dtSource">源DataTable</param>
         /// <param name="strHeaderText">表头文本</param>
         /// <param name="strFileName">保存位置</param>
         public static void ExportDTtoExcel(DataTable dtSource, string strHeaderText, string strFileName)
         {
             using (MemoryStream ms = ExportDT(dtSource, strHeaderText))
             {
                 using (FileStream fs = new FileStream(strFileName, FileMode.Create, FileAccess.Write))
                 {
                     byte[] data = ms.ToArray();
                     fs.Write(data, , data.Length);
                     fs.Flush();
                 }
             }
         }
         #endregion

         #region 从excel2003中将数据导出到datatable
         /// <summary>读取excel
         /// 默认第一行为标头
         /// </summary>
         /// <param name="strFileName">excel文档路径</param>
         /// <returns></returns>
         public static DataTable ImportExcel2003toDt(string strFileName)
         {
             DataTable dt = new DataTable();
             IWorkbook hssfworkbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 hssfworkbook = new HSSFWorkbook(file);
             }
             HSSFSheet sheet = hssfworkbook.GetSheetAt() as HSSFSheet;
             dt = ImportExcel2003InDt(sheet, , true);
             return dt;
         }

         /// <summary>读取excel
         /// 默认第一行为标头
         /// </summary>
         /// <param name="strFileName">excel文档路径</param>
         /// <returns></returns>
         public static DataTable ImportExcel2007toDt(string strFileName)
         {
             DataTable dt = new DataTable();
             IWorkbook hssfworkbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 hssfworkbook = new XSSFWorkbook(file);
             }
             ISheet sheet = hssfworkbook.GetSheetAt();
             dt = ImportExcel2007InDt(sheet, , true);
             return dt;
         }

         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2003toDt(string strFileName, string SheetName, int HeaderRowIndex)
         {
             IWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new HSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheet(SheetName) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2003InDt(sheet, HeaderRowIndex, true);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2007toDt(string strFileName, string SheetName, int HeaderRowIndex)
         {
             IWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new XSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheet(SheetName) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2007InDt(sheet, HeaderRowIndex, true);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet序号</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2003toDt(string strFileName, int SheetIndex, int HeaderRowIndex)
         {
             HSSFWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new HSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheetAt(SheetIndex) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2003InDt(sheet, HeaderRowIndex, true);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }
         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet序号</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2007toDt(string strFileName, int SheetIndex, int HeaderRowIndex)
         {
             IWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new XSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheetAt(SheetIndex) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2007InDt(sheet, HeaderRowIndex, true);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2003toDt(string strFileName, string SheetName, int HeaderRowIndex, bool needHeader)
         {
             IWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new HSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheet(SheetName) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2003InDt(sheet, HeaderRowIndex, needHeader);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         /// <summary>
         /// 读取excel
         /// </summary>
         /// <param name="strFileName">excel文件路径</param>
         /// <param name="sheet">需要导出的sheet序号</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         public static DataTable ImportExcel2003toDt(string strFileName, int SheetIndex, int HeaderRowIndex, bool needHeader)
         {
             HSSFWorkbook workbook;
             using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
             {
                 workbook = new HSSFWorkbook(file);
             }
             HSSFSheet sheet = workbook.GetSheetAt(SheetIndex) as HSSFSheet;
             DataTable table = new DataTable();
             table = ImportExcel2003InDt(sheet, HeaderRowIndex, needHeader);
             //ExcelFileStream.Close();
             workbook = null;
             sheet = null;
             return table;
         }

         static DataTable ImportExcel2003InDt(ISheet sheet, int HeaderRowIndex, bool needHeader)
         {
             DataTable table = new DataTable();
             HSSFRow headerRow;
             int cellCount;
             try
             {
                 if (HeaderRowIndex <  || !needHeader)
                 {
                     headerRow = sheet.GetRow() as HSSFRow;
                     cellCount = headerRow.LastCellNum;

                     for (int i = headerRow.FirstCellNum; i <= cellCount; i++)
                     {
                         DataColumn column = new DataColumn(Convert.ToString(i));
                         table.Columns.Add(column);
                     }
                 }
                 else
                 {
                     headerRow = sheet.GetRow(HeaderRowIndex) as HSSFRow;
                     cellCount = headerRow.LastCellNum;

                     for (int i = headerRow.FirstCellNum; i <= cellCount; i++)
                     {
                         if (headerRow.GetCell(i) == null)
                         {
                             if (table.Columns.IndexOf(Convert.ToString(i)) > )
                             {
                                 DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
                                 table.Columns.Add(column);
                             }
                             else
                             {
                                 DataColumn column = new DataColumn(Convert.ToString(i));
                                 table.Columns.Add(column);
                             }

                         }
                         else if (table.Columns.IndexOf(headerRow.GetCell(i).ToString()) > )
                         {
                             DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
                             table.Columns.Add(column);
                         }
                         else
                         {
                             DataColumn column = new DataColumn(headerRow.GetCell(i).ToString());
                             table.Columns.Add(column);
                         }
                     }
                 }
                 int rowCount = sheet.LastRowNum;
                 for (int i = (HeaderRowIndex + ); i <= sheet.LastRowNum; i++)
                 {
                     try
                     {
                         HSSFRow row;
                         if (sheet.GetRow(i) == null)
                         {
                             row = sheet.CreateRow(i) as HSSFRow;
                         }
                         else
                         {
                             row = sheet.GetRow(i) as HSSFRow;
                         }

                         DataRow dataRow = table.NewRow();

                         for (int j = row.FirstCellNum; j <= cellCount; j++)
                         {
                             try
                             {
                                 if (row.GetCell(j) != null)
                                 {
                                     switch (row.GetCell(j).CellType)
                                     {
                                         case CellType.String:
                                             string str = row.GetCell(j).StringCellValue;
                                             if (str != null && str.Length > )
                                             {
                                                 dataRow[j] = str.ToString();
                                             }
                                             else
                                             {
                                                 dataRow[j] = null;
                                             }
                                             break;
                                         case CellType.Numeric:
                                             if (DateUtil.IsCellDateFormatted(row.GetCell(j)))
                                             {
                                                 dataRow[j] = DateTime.FromOADate(row.GetCell(j).NumericCellValue);
                                             }
                                             else
                                             {
                                                 dataRow[j] = Convert.ToDouble(row.GetCell(j).NumericCellValue);
                                             }
                                             break;
                                         case CellType.Boolean:
                                             dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
                                             break;
                                         case CellType.Error:
                                             dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
                                             break;
                                         case CellType.Formula:
                                             switch (row.GetCell(j).CachedFormulaResultType)
                                             {
                                                 case CellType.String:
                                                     string strFORMULA = row.GetCell(j).StringCellValue;
                                                     if (strFORMULA != null && strFORMULA.Length > )
                                                     {
                                                         dataRow[j] = strFORMULA.ToString();
                                                     }
                                                     else
                                                     {
                                                         dataRow[j] = null;
                                                     }
                                                     break;
                                                 case CellType.Numeric:
                                                     dataRow[j] = Convert.ToString(row.GetCell(j).NumericCellValue);
                                                     break;
                                                 case CellType.Boolean:
                                                     dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
                                                     break;
                                                 case CellType.Error:
                                                     dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
                                                     break;
                                                 default:
                                                     dataRow[j] = "";
                                                     break;
                                             }
                                             break;
                                         default:
                                             dataRow[j] = "";
                                             break;
                                     }
                                 }
                             }
                             catch (Exception exception)
                             {
                                 //wl.WriteLogs(exception.ToString());
                             }
                         }
                         table.Rows.Add(dataRow);
                     }
                     catch (Exception exception)
                     {
                         //wl.WriteLogs(exception.ToString());
                     }
                 }
             }
             catch (Exception exception)
             {
                 //wl.WriteLogs(exception.ToString());
             }
             return table;
         }

         /// <summary>
         /// 将制定sheet中的数据导出到datatable中
         /// </summary>
         /// <param name="sheet">需要导出的sheet</param>
         /// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
         /// <returns></returns>
         static DataTable ImportExcel2007InDt(ISheet sheet, int HeaderRowIndex, bool needHeader)
         {
             DataTable table = new DataTable();
             NPOI.XSSF.UserModel.XSSFRow headerRow;
             int cellCount;
             try
             {
                 if (HeaderRowIndex <  || !needHeader)
                 {
                     headerRow = sheet.GetRow() as NPOI.XSSF.UserModel.XSSFRow;
                     cellCount = headerRow.LastCellNum;

                     for (int i = headerRow.FirstCellNum; i <= cellCount; i++)
                     {
                         DataColumn column = new DataColumn(Convert.ToString(i));
                         table.Columns.Add(column);
                     }
                 }
                 else
                 {
                     headerRow = sheet.GetRow(HeaderRowIndex) as NPOI.XSSF.UserModel.XSSFRow;
                     cellCount = headerRow.LastCellNum;

                     for (int i = headerRow.FirstCellNum; i <= cellCount; i++)
                     {
                         if (headerRow.GetCell(i) == null)
                         {
                             if (table.Columns.IndexOf(Convert.ToString(i)) > )
                             {
                                 DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
                                 table.Columns.Add(column);
                             }
                             else
                             {
                                 DataColumn column = new DataColumn(Convert.ToString(i));
                                 table.Columns.Add(column);
                             }

                         }
                         else if (table.Columns.IndexOf(headerRow.GetCell(i).ToString()) > )
                         {
                             DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
                             table.Columns.Add(column);
                         }
                         else
                         {
                             DataColumn column = new DataColumn(headerRow.GetCell(i).ToString());
                             table.Columns.Add(column);
                         }
                     }
                 }
                 int rowCount = sheet.LastRowNum;
                 for (int i = (HeaderRowIndex + ); i <= sheet.LastRowNum; i++)
                 {
                     try
                     {
                         NPOI.XSSF.UserModel.XSSFRow row;
                         if (sheet.GetRow(i) == null)
                         {
                             row = sheet.CreateRow(i) as NPOI.XSSF.UserModel.XSSFRow;
                         }
                         else
                         {
                             row = sheet.GetRow(i) as NPOI.XSSF.UserModel.XSSFRow;
                         }

                         DataRow dataRow = table.NewRow();

                         for (int j = row.FirstCellNum; j <= cellCount; j++)
                         {
                             try
                             {
                                 if (row.GetCell(j) != null)
                                 {
                                     switch (row.GetCell(j).CellType)
                                     {
                                         case CellType.String:
                                             string str = row.GetCell(j).StringCellValue;
                                             if (str != null && str.Length > )
                                             {
                                                 dataRow[j] = str.ToString();
                                             }
                                             else
                                             {
                                                 dataRow[j] = null;
                                             }
                                             break;
                                         case CellType.Numeric:
                                             if (DateUtil.IsCellDateFormatted(row.GetCell(j)))
                                             {
                                                 dataRow[j] = DateTime.FromOADate(row.GetCell(j).NumericCellValue);
                                             }
                                             else
                                             {
                                                 dataRow[j] = Convert.ToDouble(row.GetCell(j).NumericCellValue);
                                             }
                                             break;
                                         case CellType.Boolean:
                                             dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
                                             break;
                                         case CellType.Error:
                                             dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
                                             break;
                                         case CellType.Formula:
                                             switch (row.GetCell(j).CachedFormulaResultType)
                                             {
                                                 case CellType.String:
                                                     string strFORMULA = row.GetCell(j).StringCellValue;
                                                     if (strFORMULA != null && strFORMULA.Length > )
                                                     {
                                                         dataRow[j] = strFORMULA.ToString();
                                                     }
                                                     else
                                                     {
                                                         dataRow[j] = null;
                                                     }
                                                     break;
                                                 case CellType.Numeric:
                                                     dataRow[j] = Convert.ToString(row.GetCell(j).NumericCellValue);
                                                     break;
                                                 case CellType.Boolean:
                                                     dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
                                                     break;
                                                 case CellType.Error:
                                                     dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
                                                     break;
                                                 default:
                                                     dataRow[j] = "";
                                                     break;
                                             }
                                             break;
                                         default:
                                             dataRow[j] = "";
                                             break;
                                     }
                                 }
                             }
                             catch (Exception exception)
                             {
                                 //wl.WriteLogs(exception.ToString());
                             }
                         }
                         table.Rows.Add(dataRow);
                     }
                     catch (Exception exception)
                     {
                         //wl.WriteLogs(exception.ToString());
                     }
                 }
             }
             catch (Exception exception)
             {
                 //wl.WriteLogs(exception.ToString());
             }
             return table;
         }
         #endregion

         #region 更新excel中的数据

         //批量更新，必须所有的excel都是一样的格式
         public static void UpdateExcelBatch(string outputFile, List<DataTable> pListTable)
         {
             //列从0开始
             //行从0开始
             int coluid = ;
             int rowid = ;

             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);

             foreach (DataTable pTable in pListTable)
             {
                 string sheetname = pTable.TableName;//对应excel的sheet
                 ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
                 int rownum = ;
                 int column = ;
                 foreach (DataRow pRow in pTable.Rows)
                 {
                     try
                     {
                         IRow pR = sheet1.CreateRow(rownum);
                         for (int k = ; k < pTable.Columns.Count; k++)
                         {
                             column = k + coluid;//列从0开始
                             ICell pCell = pR.CreateCell(column);
                             pCell.SetCellValue(pRow[k].ToString());
                         }
                         rownum++;
                         //  column++;
                     }
                     catch (Exception ex)
                     {
                         // wl.WriteLogs(ex.ToString());
                         throw;
                     }
                 }
             }
             try
             {
                 readfile.Close();
                 FileStream writefile = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 // wl.WriteLogs(ex.ToString());
             }

         }

         public static void UpdateExcel(string outputFile, string sheetname, DataTable pTable)
         {
             //列从0开始
             //行从0开始
             int coluid = ;
             int rowid = ;

             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
             ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
             int rownum = ;
             int column = ;
             foreach (DataRow pRow in pTable.Rows)
             {
                 try
                 {
                     IRow pR = sheet1.CreateRow(rownum);
                     for (int k = ; k < pTable.Columns.Count; k++)
                     {
                         column = k + coluid;//列从0开始
                         ICell pCell = pR.CreateCell(column);
                         pCell.SetCellValue(pRow[k].ToString());
                     }
                     rownum++;
                     //  column++;
                 }
                 catch (Exception ex)
                 {
                     // wl.WriteLogs(ex.ToString());
                     throw;
                 }
             }
             try
             {
                 readfile.Close();
                 FileStream writefile = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 // wl.WriteLogs(ex.ToString());
             }

         }
         /// <summary>
         /// 更新Excel表格
         /// </summary>
         /// <param name="outputFile">需更新的excel表格路径</param>
         /// <param name="sheetname">sheet名</param>
         /// <param name="updateData">需更新的数据</param>
         /// <param name="coluid">需更新的列号</param>
         /// <param name="rowid">需更新的开始行号</param>
         public static void UpdateExcel(string outputFile, string sheetname, string[] updateData, int coluid, int rowid)
         {
             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
             ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
             for (int i = ; i < updateData.Length; i++)
             {
                 try
                 {
                     if (sheet1.GetRow(i + rowid) == null)
                     {
                         sheet1.CreateRow(i + rowid);
                     }
                     if (sheet1.GetRow(i + rowid).GetCell(coluid) == null)
                     {
                         sheet1.GetRow(i + rowid).CreateCell(coluid);
                     }

                     sheet1.GetRow(i + rowid).GetCell(coluid).SetCellValue(updateData[i]);
                 }
                 catch (Exception ex)
                 {
                     // wl.WriteLogs(ex.ToString());
                     throw;
                 }
             }
             try
             {
                 readfile.Close();
                 FileStream writefile = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 // wl.WriteLogs(ex.ToString());
             }

         }

         /// <summary>
         /// 更新Excel表格
         /// </summary>
         /// <param name="outputFile">需更新的excel表格路径</param>
         /// <param name="sheetname">sheet名</param>
         /// <param name="updateData">需更新的数据</param>
         /// <param name="coluids">需更新的列号</param>
         /// <param name="rowid">需更新的开始行号</param>
         public static void UpdateExcel(string outputFile, string sheetname, string[][] updateData, int[] coluids, int rowid)
         {
             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
             readfile.Close();
             ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
             for (int j = ; j < coluids.Length; j++)
             {
                 for (int i = ; i < updateData[j].Length; i++)
                 {
                     try
                     {
                         if (sheet1.GetRow(i + rowid) == null)
                         {
                             sheet1.CreateRow(i + rowid);
                         }
                         if (sheet1.GetRow(i + rowid).GetCell(coluids[j]) == null)
                         {
                             sheet1.GetRow(i + rowid).CreateCell(coluids[j]);
                         }
                         sheet1.GetRow(i + rowid).GetCell(coluids[j]).SetCellValue(updateData[j][i]);
                     }
                     catch (Exception ex)
                     {
                         // wl.WriteLogs(ex.ToString());
                     }
                 }
             }
             try
             {
                 FileStream writefile = new FileStream(outputFile, FileMode.Create);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 //wl.WriteLogs(ex.ToString());
             }
         }

         /// <summary>
         /// 更新Excel表格
         /// </summary>
         /// <param name="outputFile">需更新的excel表格路径</param>
         /// <param name="sheetname">sheet名</param>
         /// <param name="updateData">需更新的数据</param>
         /// <param name="coluid">需更新的列号</param>
         /// <param name="rowid">需更新的开始行号</param>
         public static void UpdateExcel(string outputFile, string sheetname, double[] updateData, int coluid, int rowid)
         {
             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
             ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
             for (int i = ; i < updateData.Length; i++)
             {
                 try
                 {
                     if (sheet1.GetRow(i + rowid) == null)
                     {
                         sheet1.CreateRow(i + rowid);
                     }
                     if (sheet1.GetRow(i + rowid).GetCell(coluid) == null)
                     {
                         sheet1.GetRow(i + rowid).CreateCell(coluid);
                     }

                     sheet1.GetRow(i + rowid).GetCell(coluid).SetCellValue(updateData[i]);
                 }
                 catch (Exception ex)
                 {
                     //wl.WriteLogs(ex.ToString());
                     throw;
                 }
             }
             try
             {
                 readfile.Close();
                 FileStream writefile = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 //wl.WriteLogs(ex.ToString());
             }

         }

         /// <summary>
         /// 更新Excel表格
         /// </summary>
         /// <param name="outputFile">需更新的excel表格路径</param>
         /// <param name="sheetname">sheet名</param>
         /// <param name="updateData">需更新的数据</param>
         /// <param name="coluids">需更新的列号</param>
         /// <param name="rowid">需更新的开始行号</param>
         public static void UpdateExcel(string outputFile, string sheetname, double[][] updateData, int[] coluids, int rowid)
         {
             FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

             HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
             readfile.Close();
             ISheet sheet1 = hssfworkbook.GetSheet(sheetname);
             for (int j = ; j < coluids.Length; j++)
             {
                 for (int i = ; i < updateData[j].Length; i++)
                 {
                     try
                     {
                         if (sheet1.GetRow(i + rowid) == null)
                         {
                             sheet1.CreateRow(i + rowid);
                         }
                         if (sheet1.GetRow(i + rowid).GetCell(coluids[j]) == null)
                         {
                             sheet1.GetRow(i + rowid).CreateCell(coluids[j]);
                         }
                         sheet1.GetRow(i + rowid).GetCell(coluids[j]).SetCellValue(updateData[j][i]);
                     }
                     catch (Exception ex)
                     {
                         //wl.WriteLogs(ex.ToString());
                     }
                 }
             }
             try
             {
                 FileStream writefile = new FileStream(outputFile, FileMode.Create);
                 hssfworkbook.Write(writefile);
                 writefile.Close();
             }
             catch (Exception ex)
             {
                 //wl.WriteLogs(ex.ToString());
             }
         }

         #endregion

         public static int GetSheetNumber(string outputFile)
         {
             int number = ;
             try
             {
                 FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

                 HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
                 number = hssfworkbook.NumberOfSheets;

             }
             catch (Exception exception)
             {
                 //wl.WriteLogs(exception.ToString());
             }
             return number;
         }

         public static List<string> GetSheetName(string outputFile)
         {
             List<string> arrayList = new List<string>();
             try
             {
                 FileStream readfile = new FileStream(outputFile, FileMode.Open, FileAccess.Read);

                 HSSFWorkbook hssfworkbook = new HSSFWorkbook(readfile);
                 for (int i = ; i < hssfworkbook.NumberOfSheets; i++)
                 {
                     arrayList.Add(hssfworkbook.GetSheetName(i));
                 }
             }
             catch (Exception exception)
             {
                 //wl.WriteLogs(exception.ToString());
             }
             return arrayList;
         }

         public static bool isNumeric(String message, out double result)
         {
             Regex rex = new Regex(@"^[-]?\d+[.]?\d*$");
             result = -;
             if (rex.IsMatch(message))
             {
                 result = double.Parse(message);
                 return true;
             }
             else
                 return false;

         }
     }
 }