C#代码实现 Excel表格与Object互相转换，Excel表格导入数据库（.NET2.0 .NET4.0）

前些天在工作上遇到这个需求，在GitHub找到一个开源代码可以用，Fork了一个版本，整理一下发出来。

①.Net项目中使用Nuget安装一个 NPOI 包    https://github.com/tonyqus/npoi

②再Nuget安装 Chsword.Excel2Object 包    https://github.com/chsword/Excel2Object

　也可以直接使用命令行（“Install-Package Chsword.Excel2Object”）

注：上述程序包是作者的源代码，如果项目的.NET版本太低（2.0神马的），比如我们╮(╯▽╰)╭ ，可以跳过此步骤直接复制下面的代码。

　　 我把.NET4.0的语法都替换掉了，用到的类都揉到一个页面了，没有作者那么条理清晰，引用方便一些。

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using NPOI.HSSF.UserModel;
 using NPOI.SS.UserModel;

 namespace Bu.Function
 {

     /// <summary>
     /// excel转object
     /// </summary>

     public class ExcelAttribute : Attribute
     {
         public ExcelAttribute(string name)
         {
             Title = name;
         }

         public int Order { get; set; }
         public string Title { get; set; }
     }

     public class ExcelImporter
     {
         public IEnumerable<TModel> ExcelToObject<TModel>(string path, int? type = null) where TModel : class, new()
         {
             var result = GetDataRows(path);
             var dict = ExcelUtil.GetExportAttrDict<TModel>();
             var dictColumns = new Dictionary<int, KeyValuePair<PropertyInfo, ExcelAttribute>>();

             IEnumerator rows = result;

             var titleRow = (IRow)rows.Current;
             if (titleRow != null)
                 foreach (var cell in titleRow.Cells)
                 {
                     var prop = new KeyValuePair<PropertyInfo, ExcelAttribute>();
                     foreach (var item in dict)
                     {
                         if (cell.StringCellValue == item.Value.Title)
                         {
                             prop = item;
                         }
                     }

                     if (prop.Key != null && !dictColumns.ContainsKey(cell.ColumnIndex))
                     {
                         dictColumns.Add(cell.ColumnIndex, prop);
                     }
                 }
             while (rows.MoveNext())
             {
                 var row = (IRow)rows.Current;
                 if (row != null)
                 {
                     var firstCell = row.GetCell();
                     if (firstCell == null || firstCell.CellType == CellType.Blank ||
                         string.IsNullOrEmpty(firstCell.ToString()))
                         continue;
                 }

                 var model = new TModel();

                 foreach (var pair in dictColumns)
                 {
                     var propType = pair.Value.Key.PropertyType;
                     if (propType == typeof(DateTime?) ||
                         propType == typeof(DateTime))
                     {
                         pair.Value.Key.SetValue(model, GetCellDateTime(row, pair.Key), null);
                     }
                     else
                     {

                         try
                         {
                             var  val= Convert.ChangeType(GetCellValue(row, pair.Key), propType);
                             pair.Value.Key.SetValue(model, val, null);
                         }
                         catch (Exception ex)
                         {
                             break;
                         }

                     }
                 }
                 yield return model;
             }

         }

         string GetCellValue(IRow row, int index)
         {
             var result = string.Empty;
             try
             {
                 switch (row.GetCell(index).CellType)
                 {
                     case CellType.Numeric:
                         result = row.GetCell(index).NumericCellValue.ToString();
                         break;
                     case CellType.String:
                         result = row.GetCell(index).StringCellValue;
                         break;
                     case CellType.Blank:
                         result = string.Empty;
                         break;

                     #region

                     //case CellType.Formula:
                     //    result = row.GetCell(index).CellFormula;
                     //    break;
                     //case CellType.Boolean:
                     //    result = row.GetCell(index).NumericCellValue.ToString();
                     //    break;
                     //case CellType.Error:
                     //    result = row.GetCell(index).NumericCellValue.ToString();
                     //    break;
                     //case CellType.Unknown:
                     //    result = row.GetCell(index).NumericCellValue.ToString();
                     //    break;

                     #endregion
                     default:
                         result = row.GetCell(index).ToString();
                         break;
                 }
             }
             catch (Exception e)
             {
                 Console.WriteLine(e);
             }
             return (result ?? "").Trim();
         }
         IEnumerator GetDataRows(string path)
         {
             if (string.IsNullOrEmpty(path))
                 return null;
             HSSFWorkbook hssfworkbook;
             try
             {
                 using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read))
                 {
                     hssfworkbook = new HSSFWorkbook(file);
                 }
             }
             catch (Exception)
             {
                 return null;
             }
             ISheet sheet = hssfworkbook.GetSheetAt();
             IEnumerator rows = sheet.GetRowEnumerator();
             rows.MoveNext();
             return rows;
         }

         DateTime? GetCellDateTime(IRow row, int index)
         {
             DateTime? result = null;
             try
             {
                 switch (row.GetCell(index).CellType)
                 {
                     case CellType.Numeric:
                         try
                         {
                             result = row.GetCell(index).DateCellValue;
                         }
                         catch (Exception e)
                         {
                             Console.WriteLine(e);
                         }
                         break;
                     case CellType.String:
                         var str = row.GetCell(index).StringCellValue;
                         if (str.EndsWith("年"))
                         {
                             DateTime dt;
                             if (DateTime.TryParse((str + "-01-01").Replace("年", ""), out dt))
                             {
                                 result = dt;
                             }
                         }
                         else if (str.EndsWith("月"))
                         {
                             DateTime dt;
                             if (DateTime.TryParse((str + "-01").Replace("年", "").Replace("月", ""), out dt))
                             {
                                 result = dt;
                             }
                         }
                         else if (!str.Contains("年") && !str.Contains("月") && !str.Contains("日"))
                         {
                             try
                             {
                                 result = Convert.ToDateTime(str);
                             }
                             catch (Exception)
                             {
                                 try
                                 {
                                     result = Convert.ToDateTime((str + "-01-01").Replace("年", "").Replace("月", ""));
                                 }
                                 catch (Exception)
                                 {
                                     result = null;
                                 }
                             }
                         }
                         else
                         {
                             DateTime dt;
                             if (DateTime.TryParse(str.Replace("年", "").Replace("月", ""), out dt))
                             {
                                 result = dt;
                             }
                         }
                         break;
                     case CellType.Blank:
                         break;
                     #region

                     #endregion
                 }
             }
             catch (Exception e)
             {
                 Console.WriteLine(e);
             }
             return result;
         }
     }

     class ExcelExporter
     {
         public byte[] ObjectToExcelBytes<TModel>(IEnumerable<TModel> data)
         {
             var workbook = new HSSFWorkbook();
             var sheet = workbook.CreateSheet();
             var attrDict = ExcelUtil.GetExportAttrDict<TModel>();
             var attrArray = new KeyValuePair<PropertyInfo, ExcelAttribute>[] { };
             int aNum = ;
             foreach (var item in attrDict)
             {
                 attrArray[aNum] = item;
                 aNum++;

             }

             for (int i = ; i < attrArray.Length; i++)
             {
                 sheet.SetColumnWidth(i,  * );
             }
             var headerRow = sheet.CreateRow();

             for (int i = ; i < attrArray.Length; i++)
             {
                 headerRow.CreateCell(i).SetCellValue(attrArray[i].Value.Title);
             }
             int rowNumber = ;
             foreach (var item in data)
             {
                 var row = sheet.CreateRow(rowNumber++);
                 for (int i = ; i < attrArray.Length; i++)
                 {
                     row.CreateCell(i).SetCellValue((attrArray[i].Key.GetValue(item, null) ?? "").ToString());
                 }
             }
             using (var output = new MemoryStream())
             {
                 workbook.Write(output);
                 var bytes = output.ToArray();
                 return bytes;
             }
         }

     }

     public class ExcelHelper
     {
         /// <summary>
         /// import file excel file to a IEnumerable of TModel
         /// </summary>
         /// <typeparam name="TModel"></typeparam>
         /// <param name="path">excel full path</param>
         /// <returns></returns>
         public static IEnumerable<TModel> ExcelToObject<TModel>(string path) where TModel : class, new()
         {
             var importer = new ExcelImporter();
             return importer.ExcelToObject<TModel>(path);

         }

         /// <summary>
         /// Export object to excel file
         /// </summary>
         /// <typeparam name="TModel"></typeparam>
         /// <param name="data">a IEnumerable of TModel</param>
         /// <param name="path">excel full path</param>
         public static void ObjectToExcel<TModel>(IEnumerable<TModel> data, string path) where TModel : class, new()
         {
             var importer = new ExcelExporter();
             var bytes = importer.ObjectToExcelBytes(data);
             File.WriteAllBytes(path, bytes);
         }
     }

     internal class ExcelUtil
     {
         public static Dictionary<PropertyInfo, ExcelAttribute> GetExportAttrDict<T>()
         {
             var dict = new Dictionary<PropertyInfo, ExcelAttribute>();
             foreach (var propertyInfo in typeof(T).GetProperties())
             {
                 var attr = new object();
                 var ppi = propertyInfo.GetCustomAttributes(true);
                 for (int i = ; i < ppi.Length; i++)
                 {
                     if (ppi[i] is ExcelAttribute)
                     {
                         attr = ppi[i];
                         break;
                     }
                 }

                 if (attr != null)
                 {

                     dict.Add(propertyInfo, attr as ExcelAttribute);

                 }
             }
             return dict;
         }
     }

 }

③准备一段 Demo Code

public class ReportModel
{
    [Excel("标题",Order=)]
    public string Title { get; set; }
    [Excel("用户",Order=)]
    public string Name { get; set; }
}

准备一个List

 var models = new List<ReportModel>
        {
            new ReportModel{Name="a",Title="b"},
            new ReportModel{Name="c",Title="d"},
            new ReportModel{Name="f",Title="e"}
        };

④由Object转为Excel

var exporter = new ExcelExporter();
  var bytes = exporter.ObjectToExcelBytes(models);
  File.WriteAllBytes("C:\\demo.xls", bytes);

由Excel转为Object

var importer = new ExcelImporter();
  IEnumerable<ReportModel> result = importer.ExcelToObject<ReportModel>("c:\\demo.xls");

转成Object再验证，存入数据库神马的 是不是就so easy啦~

---

与ASP.NET MVC结合使用

由于ASP.NET MVC中Model上会使用DisplayAttribute所以Excel2Object除了支持ExcelAttribute外，也支持DisplayAttribute。