.net core 基於NPOI 的excel導入導出類，支持自定義導出哪些字段，和判斷導入是否有失敗的記錄

#region 從Excel導入
        //用法
        //var cellHeader = new Dictionary<string, string>();
        //cellHeader.Add("dpdm","中文");
        //    cellHeader.Add("dpmc", "中文");
        //    cellHeader.Add("xz", "xz");
        //    cellHeader.Add("qy", "qy");
        //    cellHeader.Add("spdm", "spdm");
        //    cellHeader.Add("dl", "dl");
        //    cellHeader.Add("dpj", "dpj");
        //    cellHeader.Add("ys", "ys");
        //    cellHeader.Add("cm", "cm");
        //    cellHeader.Add("sl", "sl");
        //    cellHeader.Add("bzje", "bzje");
        //    cellHeader.Add("dhje", "dhje");
        //    var errorMsg = new StringBuilder();
        //var list = ExcelHelper.ExcelToEntityList<DHHSJEntity>(cellHeader, fileName, out errorMsg);
        /// <summary>
        /// 從Excel取數據並記錄到List集合里
        /// </summary>
        /// <param name="cellHeard">單元頭的值和名稱：{ { "UserName", "姓名" }, { "Age", "年齡" } };</param>
        /// <param name="filePath">保存文件絕對路徑</param>
        /// <param name="errorMsg">錯誤信息</param>
        /// <returns>轉換后的List對象集合</returns>
        public static List<T> ExcelToEntityList<T>(Dictionary<string, string> cellHeard, string filePath, out StringBuilder errorMsg) where T : new()
        {
            List<T> enlist = new List<T>();
            errorMsg = new StringBuilder();
            try
            {
                if (Regex.IsMatch(filePath, ".xls$")) // 2003
                {
                    enlist = Excel2003ToEntityList<T>(cellHeard, filePath, out errorMsg);
                }
                else if (Regex.IsMatch(filePath, ".xlsx$")) // 2007
                {
                    //return FailureResultMsg("請選擇Excel文件"); // 未設計
                }
                return enlist;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        
        /// <summary>
        /// 從Excel2003取數據並記錄到List集合里
        /// </summary>
        /// <param name="cellHeard">單元頭的Key和Value：{ { "UserName", "姓名" }, { "Age", "年齡" } };</param>
        /// <param name="filePath">保存文件絕對路徑</param>
        /// <param name="errorMsg">錯誤信息</param>
        /// <returns>轉換好的List對象集合</returns>
        private static List<T> Excel2003ToEntityList<T>(Dictionary<string, string> cellHeard, string filePath, out StringBuilder errorMsg) where T : new()
        {
            errorMsg = new StringBuilder(); // 錯誤信息,Excel轉換到實體對象時，會有格式的錯誤信息
            List<T> enlist = new List<T>(); // 轉換后的集合
            List<string> keys = cellHeard.Keys.ToList(); // 要賦值的實體對象屬性名稱
            try
            {
                using (FileStream fs = File.OpenRead(filePath))
                {
                    HSSFWorkbook workbook = new HSSFWorkbook(fs);
                    HSSFSheet sheet = (HSSFSheet)workbook.GetSheetAt(0); // 獲取此文件第一個Sheet頁
                    for (int i = 1; i <= sheet.PhysicalNumberOfRows; i++) // 從1開始，第0行為單元頭
                    {
                        if (i >= 289)
                        {

                        }
                        // 1.判斷當前行是否空行，若空行就不在進行讀取下一行操作，結束Excel讀取操作
                        if (sheet.GetRow(i) == null)
                        {
                            break;
                        }
                        //var cells = sheet.GetRow(i).Cells;
                        //var flag = false;
                        //for(int t=0;t<cells.Count;t++)
                        //{
                        //  //var a = sheet.GetRow(i).GetCell(t);
                        //  //  if (!string.IsNullOrEmpty(sheet.GetRow(i).GetCell(t).ToString()))
                        //  //  {
                        //  //      flag = true;
                        //  //  }
                        //}
                        //if (!flag)
                        //{
                        //    break;
                        //}


                        T en = new T();
                        string errStr = ""; // 當前行轉換時，是否有錯誤信息，格式為：第1行數據轉換異常：XXX列；
                        for (int j = 0; j < keys.Count; j++)
                        {
                            // 2.若屬性頭的名稱包含'.',就表示是子類里的屬性，那么就要遍歷子類，eg：UserEn.TrueName
                            if (keys[j].IndexOf(".") >= 0)
                            {
                                // 2.1解析子類屬性
                                string[] properotyArray = keys[j].Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
                                string subClassName = properotyArray[0]; // '.'前面的為子類的名稱
                                string subClassProperotyName = properotyArray[1]; // '.'后面的為子類的屬性名稱
                                System.Reflection.PropertyInfo subClassInfo = en.GetType().GetProperty(subClassName); // 獲取子類的類型
                                if (subClassInfo != null)
                                {
                                    // 2.1.1 獲取子類的實例
                                    var subClassEn = en.GetType().GetProperty(subClassName).GetValue(en, null);
                                    // 2.1.2 根據屬性名稱獲取子類里的屬性信息
                                    System.Reflection.PropertyInfo properotyInfo = subClassInfo.PropertyType.GetProperty(subClassProperotyName);
                                    if (properotyInfo != null)
                                    {
                                        try
                                        {

                                            // Excel單元格的值轉換為對象屬性的值，若類型不對，記錄出錯信息
                                            properotyInfo.SetValue(subClassEn, GetExcelCellToProperty(properotyInfo.PropertyType, sheet.GetRow(i).GetCell(j), errStr).Item1, null);
                                        }
                                        catch (Exception e)
                                        {
                                            if (errStr.Length == 0)
                                            {
                                                errStr = "第" + i + "行數據轉換異常：";
                                            }
                                            errStr += cellHeard[keys[j]] + "列；";
                                        }

                                    }
                                }
                            }
                            else
                            {
                                // 3.給指定的屬性賦值
                                System.Reflection.PropertyInfo properotyInfo = en.GetType().GetProperty(keys[j]);
                                if (properotyInfo != null)
                                {
                                    try
                                    {
                                        if (GetExcelCellToProperty(properotyInfo.PropertyType, sheet.GetRow(i).GetCell(j), errStr).Item2.Length != 0)
                                        {
                                            errStr += cellHeard[keys[j]] + "列";
                                        }
                                        // Excel單元格的值轉換為對象屬性的值，若類型不對，記錄出錯信息
                                        properotyInfo.SetValue(en, GetExcelCellToProperty(properotyInfo.PropertyType, sheet.GetRow(i).GetCell(j), errStr).Item1, null);
                                    }
                                    catch (Exception e)
                                    {
                                        if (errStr.Length == 0)
                                        {
                                            errStr = "第" + i + "行數據轉換異常：";
                                        }
                                        errStr += cellHeard[keys[j]] + "列；";
                                    }
                                }
                            }
                        }
                        // 若有錯誤信息，就添加到錯誤信息里
                        if (errStr.Length > 0)
                        {
                            errorMsg.AppendLine(errStr);
                        }
                        enlist.Add(en);
                    }
                }
                return enlist;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 從Excel獲取值傳遞到對象的屬性里
        /// </summary>
        /// <param name="distanceType">目標對象類型</param>
        /// <param name="sourceCell">對象屬性的值</param>
        private static Tuple<Object, string> GetExcelCellToProperty(Type distanceType, ICell sourceCell, string errStr)
        {
            object rs = distanceType.IsValueType ? Activator.CreateInstance(distanceType) : null;

            // 1.判斷傳遞的單元格是否為空
            if (sourceCell == null || string.IsNullOrEmpty(sourceCell.ToString()))
            {
                return new Tuple<Object, string>(rs, errStr);
            }

            // 2.Excel文本和數字單元格轉換，在Excel里文本和數字是不能進行轉換，所以這里預先存值
            object sourceValue = null;
            switch (sourceCell.CellType)
            {
                case CellType.Blank:
                    break;

                case CellType.Boolean:
                    break;

                case CellType.Error:
                    break;

                case CellType.Formula:
                    break;

                case CellType.Numeric:
                    sourceValue = sourceCell.NumericCellValue;
                    break;

                case CellType.String:
                    sourceValue = sourceCell.StringCellValue;
                    break;

                case CellType.Unknown:
                    errStr += "數據轉換異常";
                    break;

                default:
                    break;
            }

            string valueDataType = distanceType.Name;

            // 在這里進行特定類型的處理
            switch (valueDataType.ToLower()) // 以防出錯，全部小寫
            {
                case "string":
                    rs = sourceValue.ToString();
                    break;
                case "int":
                case "int16":
                case "int32":
                    rs = (int)Convert.ChangeType(sourceValue, distanceType);
                    break;
                case "float":
                case "single":
                    rs = (float)Convert.ChangeType(sourceValue, distanceType);
                    break;
                case "double":
                    rs = (double)Convert.ChangeType(sourceValue, distanceType);
                    break;
                case "decimal":
                    rs = (decimal)Convert.ChangeType(sourceValue, distanceType);
                    break;
                case "datetime":
                    rs = sourceCell.DateCellValue;
                    break;
                case "guid":
                    rs = (Guid)Convert.ChangeType(sourceValue, distanceType);
                    return new Tuple<Object, string>(rs, errStr);
            }
            return new Tuple<Object, string>(rs, errStr);
        }
        #endregion

 

/// <summary>  
        /// 導出Excel  
        /// </summary>  
        /// <param name="lists"></param>  
        /// <param name="head">英文中文列名對照</param>  
        /// <param name="workbookFile">保存路徑</param>  
        public static void getExcel<T>(List<T> lists, Dictionary<string,string> head, string workbookFile)
        {
            try
            {

                XSSFWorkbook workbook = new XSSFWorkbook();
                using (MemoryStream ms = new MemoryStream())
                {
                    var sheet = workbook.CreateSheet();
                    var headerRow = sheet.CreateRow(0);
                    bool h = false;
                    int j = 1;
                    Type type = typeof(T);
                    PropertyInfo[] properties = type.GetProperties();
                    foreach (T item in lists)
                    {
                        var dataRow = sheet.CreateRow(j);
                        int i = 0;
                        foreach (PropertyInfo column in properties)
                        {
                            if (!h)
                            {
                                if (head.Keys.Contains(column.Name))
                                {
                                    headerRow.CreateCell(i).SetCellValue(head[column.Name] == null ? column.Name : head[column.Name].ToString());
                                    dataRow.CreateCell(i).SetCellValue(column.GetValue(item, null) == null ? "" : column.GetValue(item, null).ToString());

                                }
                                else
                                {
                                    i -= 1;
                                }

                            }
                            else
                            {
                                if (head.Keys.Contains(column.Name))
                                {
                                    dataRow.CreateCell(i).SetCellValue(column.GetValue(item, null) == null ? "" : column.GetValue(item, null).ToString());
                                }
                                else
                                {
                                    i -= 1;
                                }

                            }
                            i++;
                        }
                        h = true;
                        j++;
                    }
                   
                    workbook.Write(ms);
                    using (FileStream fs = new FileStream(workbookFile, FileMode.Create, FileAccess.Write))
                    {
                        byte[] data = ms.ToArray();
                        fs.Write(data, 0, data.Length);
                        fs.Flush();
                    }
                    sheet = null;
                    headerRow = null;
                    workbook = null;
                }
            }
            catch (Exception ee)
            {
                string see = ee.Message;
            }
        }