NPOI读取Excel2003,2007

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

 namespace DMEnterpriseAdministration
 {
     public class Excel
     {
         public static MemoryStream WriteDataToExcel(DataSet ds)
         {
             MemoryStream memoryStream = new MemoryStream();

             try
             {
                 IWorkbook workbook = new HSSFWorkbook();

                 foreach (DataTable table in ds.Tables)
                 {
                     ISheet sheet = workbook.CreateSheet(table.TableName);
                     IRow headerRow = sheet.CreateRow();

                     foreach (DataColumn column in table.Columns)
                     {
                         headerRow.CreateCell(column.Ordinal).SetCellValue(column.ColumnName);
                     }

                     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++;
                     }

                     sheet = null;
                     headerRow = null;
                 }

                 workbook.Write(memoryStream);

                 workbook = null;
             }
             catch (Exception exception)
             {
                 throw exception;
             }

             return memoryStream;
         }

         public static DataSet ExcelToDataSet(string excelPath)
         {
             return ExcelToDataSet(excelPath, true);
         }

         public static DataSet ExcelToDataSet(string excelPath, bool firstRowAsHeader)
         {
             int sheetCount;
             return ExcelToDataSet(excelPath, firstRowAsHeader, out sheetCount);
         }

         public static DataSet ExcelToDataSet(string excelPath, bool firstRowAsHeader, out int sheetCount)
         {
             using (DataSet ds = new DataSet())
             {
                 using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
                 {
                     IWorkbook workbook = new HSSFWorkbook(fileStream);

                     HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);

                     sheetCount = workbook.NumberOfSheets;

                     for (int i = ; i < sheetCount; ++i)
                     {
                         ISheet sheet = workbook.GetSheetAt(i) as HSSFSheet;
                         DataTable dt = ExcelToDataTable(sheet, evaluator, firstRowAsHeader);
                         ds.Tables.Add(dt);
                     }

                     return ds;
                 }
             }
         }

         public static DataTable ExcelToDataTable(string excelPath, string sheetName)
         {
             return ExcelToDataTable(excelPath, sheetName, true);
         }

         public static DataTable ExcelToDataTable(string excelPath, string sheetName, bool firstRowAsHeader)
         {
             using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
             {
                 IWorkbook workbook = null;
                 IFormulaEvaluator evaluator = null;
                 ISheet sheet  = null;
                 if (excelPath.EndsWith(".xls"))
                 {
                     workbook = new HSSFWorkbook(fileStream);
                     evaluator = new HSSFFormulaEvaluator(workbook);
                     sheet = workbook.GetSheet(sheetName) as HSSFSheet;
                     if (sheet == null)
                     {
                         sheet = workbook.GetSheetAt();
                     }
                 }
                 else
                 {
                     workbook = new XSSFWorkbook(fileStream);
                     evaluator = new XSSFFormulaEvaluator(workbook);
                     sheet = workbook.GetSheet(sheetName) as XSSFSheet;
                     if (sheet == null)
                     {
                         sheet = workbook.GetSheetAt();
                     }
                 }

                 return ExcelToDataTable(sheet, evaluator, firstRowAsHeader);
             }
         }

         private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator, bool firstRowAsHeader)
         {
             if (firstRowAsHeader)
             {
                 return ExcelToDataTableFirstRowAsHeader(sheet, evaluator);
             }
             else
             {
                 return ExcelToDataTable(sheet, evaluator);
             }
         }

         private static DataTable ExcelToDataTableFirstRowAsHeader(ISheet sheet, IFormulaEvaluator evaluator)
         {
             using (DataTable dt = new DataTable())
             {
                 IRow firstRow = sheet.GetRow() as IRow;
                 int cellCount = GetCellCount(sheet);

                 for (int i = ; i < cellCount; i++)
                 {
                     if (firstRow.GetCell(i) != null)
                     {
                         dt.Columns.Add(firstRow.GetCell(i).StringCellValue ?? string.Format("F{0}", i + ), typeof(string));
                     }
                     else
                     {
                         dt.Columns.Add(string.Format("F{0}", i + ), typeof(string));
                     }
                 }

                 for (int i = ; i <= sheet.LastRowNum; i++)
                 {
                     IRow row = sheet.GetRow(i) as IRow;
                     DataRow dr = dt.NewRow();
                     FillDataRowByHSSFRow(row, evaluator, ref dr);
                     dt.Rows.Add(dr);
                 }

                 dt.TableName = sheet.SheetName;
                 return dt;
             }
         }

         private static DataTable ExcelToDataTable(ISheet sheet, IFormulaEvaluator evaluator)
         {
             using (DataTable dt = new DataTable())
             {
                 if (sheet.LastRowNum != )
                 {
                     int cellCount = GetCellCount(sheet);

                     for (int i = ; i < cellCount; i++)
                     {
                         dt.Columns.Add(string.Format("F{0}", i), typeof(string));
                     }

                     for (int i = ; i < sheet.FirstRowNum; ++i)
                     {
                         DataRow dr = dt.NewRow();
                         dt.Rows.Add(dr);
                     }

                     for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; i++)
                     {
                         IRow row = sheet.GetRow(i) as IRow;
                         DataRow dr = dt.NewRow();
                         FillDataRowByHSSFRow(row, evaluator, ref dr);
                         dt.Rows.Add(dr);
                     }
                 }

                 dt.TableName = sheet.SheetName;
                 return dt;
             }
         }

         private static void FillDataRowByHSSFRow(IRow row, IFormulaEvaluator evaluator, ref DataRow dr)
         {
             if (row != null)
             {
                 for (int j = ; j < dr.Table.Columns.Count; j++)
                 {
                     ICell cell = row.GetCell(j) as ICell;

                     if (cell != null)
                     {
                         switch (cell.CellType)
                         {
                             case CellType.Blank:
                                 dr[j] = DBNull.Value;
                                 break;
                             case CellType.Boolean:
                                 dr[j] = cell.BooleanCellValue;
                                 break;
                             case CellType.Numeric:
                                 if (DateUtil.IsCellDateFormatted(cell))
                                 {
                                     dr[j] = cell.DateCellValue;
                                 }
                                 else
                                 {
                                     dr[j] = cell.NumericCellValue;
                                 }
                                 break;
                             case CellType.String:
                                 dr[j] = cell.StringCellValue;
                                 break;
                             case CellType.Error:
                                 dr[j] = cell.ErrorCellValue;
                                 break;
                             case CellType.Formula:
                                 cell = evaluator.EvaluateInCell(cell) as ICell;
                                 dr[j] = cell.ToString();
                                 break;
                             default:
                                 throw new NotSupportedException(string.Format("Catched unhandle CellType[{0}]", cell.CellType));
                         }
                     }
                 }
             }
         }

         private static int GetCellCount(ISheet sheet)
         {
             int firstRowNum = sheet.FirstRowNum;

             int cellCount = ;

             for (int i = sheet.FirstRowNum; i <= sheet.LastRowNum; ++i)
             {
                 IRow row = sheet.GetRow(i) as IRow;

                 if (row != null && row.LastCellNum > cellCount)
                 {
                     cellCount = row.LastCellNum;
                 }
             }

             return cellCount;
         }
     }
 }