从excel文件中获取数据(2)

本方法引用 Aspose.Cells.dll，ICSharpCode.SharpZipLib.dll ，NPOI.dll，NPOI.OOXML.dll，NPOI.OpenXml4Net.dll，NPOI.OpenXmlFormats.dll

static void Main(string[] args)
        {
            string filepath = @"E:\我的.xlsx";

            IReadEntDataFromExcel iReadEntDataFromExcel = new  ReadEntDataFromExcelInfo();
            List<String> result=iReadEntDataFromExcel.ReadEntDataFromExcel(filepath);
        }

建一个类IReadEntDataFromExcel.cs:

public interface IReadEntDataFromExcel
    {
       List<string> ReadEntDataFromExcel(string filePath);
    }

建一个类NOPIExcelHelper.cs  :

public class NOPIExcelHelper
    {
        #region 单例定义
        private static object lockObject = new object();
        protected NOPIExcelHelper()
        {
        }

        private static volatile NOPIExcelHelper _instance;
        public static NOPIExcelHelper Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (lockObject)
                    {
                        return _instance ?? (_instance = new NOPIExcelHelper());
                    }
                }
                return _instance;
            }
        }

        #endregion 单例定义

        public static DataSet ExcelToDataSet(string excelPath)
        {
            DataSet dataSet = new DataSet();
            dataSet = ExcelToDataSet(excelPath, false);
            return dataSet;
        }

        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)
        {
            sheetCount = 0;
            using (DataSet ds = new DataSet())
            {
                using (FileStream fileStream = new FileStream(excelPath, FileMode.Open, FileAccess.Read))
                {
                    if (Path.GetExtension(excelPath).ToLower() == ".xls".ToLower())
                    {
                        HSSFWorkbook workbook = new HSSFWorkbook(fileStream);
                        HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);

                        sheetCount = workbook.NumberOfSheets;

                        for (int i = 0; i < sheetCount; ++i)
                        {
                            HSSFSheet sheet = workbook.GetSheetAt(i) as HSSFSheet;
                            DataTable dt = ExcelToDataTable(sheet, evaluator, firstRowAsHeader);
                            ds.Tables.Add(dt);
                        }
                    }
                    else if (Path.GetExtension(excelPath).ToLower() == ".xlsx".ToLower())
                    {
                        XSSFWorkbook workbook = new XSSFWorkbook(fileStream);
                        XSSFFormulaEvaluator evaluator = new XSSFFormulaEvaluator(workbook);

                        sheetCount = workbook.NumberOfSheets;

                        for (int i = 0; i < sheetCount; ++i)
                        {
                            XSSFSheet sheet = workbook.GetSheetAt(i) as XSSFSheet;
                            DataTable dt = ExcelToDataTableX(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))
            {
                HSSFWorkbook workbook = new HSSFWorkbook(fileStream);

                HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);

                HSSFSheet sheet = workbook.GetSheet(sheetName) as HSSFSheet;

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

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

        private static DataTable ExcelToDataTableX(XSSFSheet sheet, XSSFFormulaEvaluator evaluator, bool firstRowAsHeader)
        {
            if (firstRowAsHeader)
            {
                return ExcelToDataTableFirstRowAsHeaderX(sheet, evaluator);
            }
            else
            {
                return ExcelToDataTableX(sheet, evaluator);
            }
        }
        private static DataTable ExcelToDataTableFirstRowAsHeader(HSSFSheet sheet, HSSFFormulaEvaluator evaluator)
        {
            using (DataTable dt = new DataTable())
            {
                HSSFRow firstRow = sheet.GetRow(0) as HSSFRow;
                int cellCount = GetCellCount(sheet);

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

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

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

        private static DataTable ExcelToDataTableFirstRowAsHeaderX(XSSFSheet sheet, XSSFFormulaEvaluator evaluator)
        {
            using (DataTable dt = new DataTable())
            {
                XSSFRow firstRow = sheet.GetRow(0) as XSSFRow;
                int cellCount = GetCellCountX(sheet);

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

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

                dt.TableName = sheet.SheetName;
                return dt;
            }
        }
        private static DataTable ExcelToDataTable(HSSFSheet sheet, HSSFFormulaEvaluator evaluator)
        {
            using (DataTable dt = new DataTable())
            {
                if (sheet.LastRowNum != 0)
                {
                    int cellCount = GetCellCount(sheet);

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

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

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

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

        private static DataTable ExcelToDataTableX(XSSFSheet sheet, XSSFFormulaEvaluator evaluator)
        {
            using (DataTable dt = new DataTable())
            {
                if (sheet.LastRowNum != 0)
                {
                    int cellCount = GetCellCountX(sheet);

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

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

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

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

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

                    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 HSSFCell;
                                dr[j] = cell.ToString();
                                break;
                            default:
                                throw new NotSupportedException(string.Format("Catched unhandle CellType[{0}]", cell.CellType));
                        }
                    }
                }
            }
        }
        private static void FillDataRowByHSSFRowX(XSSFRow row, XSSFFormulaEvaluator evaluator, ref DataRow dr)
        {
            if (row != null)
            {
                for (int j = 0; j < dr.Table.Columns.Count; j++)
                {
                    XSSFCell cell = row.GetCell(j) as XSSFCell;

                    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 XSSFCell;
                                dr[j] = cell.ToString();
                                break;
                            default:
                                throw new NotSupportedException(string.Format("Catched unhandle CellType[{0}]", cell.CellType));
                        }
                    }
                }
            }
        }

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

            int cellCount = 0;

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

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

            return cellCount;
        }

        private static int GetCellCountX(XSSFSheet sheet)
        {
            int firstRowNum = sheet.FirstRowNum;

            int cellCount = 0;

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

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

            return cellCount;
        }
    }

建一个类ReadEntDataFromExcel.cs :

public class ReadEntDataFromExcelInfo : IReadEntDataFromExcel
    {
        #region 单例定义
        private static object lockObject = new object();
        public ReadEntDataFromExcelInfo()
        {
        }

        private static volatile ReadEntDataFromExcelInfo _instance;
        public static ReadEntDataFromExcelInfo Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (lockObject)
                    {
                        return _instance ?? (_instance = new ReadEntDataFromExcelInfo());
                    }
                }
                return _instance;
            }
        }

        #endregion 单例定义

        //protected IWriteLogMess WriteLogMessProvider
        //{
        //    get
        //    {
        //        return WriteLogMess.Instance;
        //    }
        //}

        public List<string> ReadEntDataFromExcel(string filePath)
        {
            //string filePath = @"E:\Table\企业征信存量数据名单表0630.xlsx";
            List<string> result = null;
            if (string.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException("ReadEntDataFromExcel 参数为空");
            }
            try
            {
                result = this.ReadEntDataFromExcelProvider(filePath);
            }
            catch (Exception ex)
            {
                //this.WriteLogMessProvider.WritreLogExption(ex, "ReadEntDataFromExcelInfo/ReadEntDataFromExcel");
            }

            return result;
        }

        private List<string> ReadEntDataFromExcelProvider(string filePath)
        {
            NOPIExcelHelper NPOIHandler = NOPIExcelHelper.Instance;
            DataSet dataSet = new DataSet();
            dataSet = NOPIExcelHelper.ExcelToDataSet(filePath);
            DataTable table = new DataTable();

            foreach (DataTable datatable in dataSet.Tables)
            {
                table.Merge(datatable);
            }

            var hashset = new HashSet<string>();
            foreach (DataRow dr in table.Rows)
            {
                hashset.Add(dr["F1"].ToString().Trim());
            }

            List<String> result = hashset.ToList();
            return result;
        }
        //public static IList<T> ConvertTo<T>(DataTable table)
        //{
        //    if (table == null)
        //    {
        //        return null;
        //    }

        //    IList<DataRow> rows = new List<DataRow>();

        //    foreach (DataRow row in table.Rows)
        //    {
        //        rows.Add(row);
        //    }

        //    return ConvertTo<T>(rows);
        //}  

    }