C#中DataTable与泛型集合互转（支持泛型集合中对象包含枚举）

最近在做WCF，因为是内部接口，很多地方直接用的弱类型返回（DataSet），这其实是一种非常不好的方式，最近将项目做了修改，将所有接口返回值都修改成强类型，这样可以减少很多与客户端开发人员的沟通，结构内容一目了然

很多时候，后台我们通过ADO.NET使用SQL语句查询出了想要的数据，这时如果直接把这个DataSet丢给客户端开发人员，会让他们一头雾水，并且维护扩展起来都很麻烦，所以想了一个办法，在服务端，首先我们把查询到的数据集转换成泛型集合，再返回给客户端，客户端可以直接使用，也可以再自行转换成自己需要的数据格式，这样做还有一点是因为，DataTable在进行序列化与反序列化时并不那么可靠，记得在多线程同时序列化一个DataTable时会有异常，另外也隐藏了很多小问题，例如需要序列化DataTable的话必须设置TableName等等

首先是封装的辅助类，这个辅助类还可以完善，因为我这里数据库数据类型与实体对象的类型可以直接转换，如果实体类类型与数据库内类型不同，则需要做相应的转换

 static class Helper
     {
         /// <summary>
         ///  DataTable转换成泛型集合
         /// </summary>
         /// <typeparam name="T">泛型集合类型</typeparam>
         /// <param name="dt">DataTable</param>
         /// <param name="dEnum">字典集合，Key为需要从转换为enum项的DataColumnName，Value为需要转换的枚举的类型</param>
         /// <returns>以实体类为元素的泛型集合</returns>
         public static IList<T> DataTableConvertToListGenuric<T>(DataTable dt, Dictionary<string, Type> dEnum) where T : new()
         {
             if (dt?.Rows.Count > )
             {
                 // 定义集合
                 List<T> ts = new List<T>();
                 // 获得此模型的类型
                 Type type = typeof(T);
                 //定义一个临时变量
                 string tempName = string.Empty;
                 //遍历DataTable中所有的数据行
                 foreach (DataRow dr in dt.Rows)
                 {
                     T t = new T();
                     //如果T是值类型，则先进行装箱
                     object obj = null;
                     if (!t.GetType().IsClass)
                     {
                         obj = t;
                     }
                     //获得此模型的公共属性
                     PropertyInfo[] propertys = t.GetType().GetProperties();
                     //遍历该对象的所有属性
                     foreach (PropertyInfo pi in propertys)
                     {
                         //将属性名称赋值给临时变量
                         tempName = pi.Name;
                         //检查DataTable是否包含此列（列名==对象的属性名）
                         if (dt.Columns.Contains(tempName))
                         {
                             // 判断此属性是否有Setter
                             if (!pi.CanWrite) continue;//该属性不可写，直接跳出
                             //取值
                             object value = dr[tempName];
                             //如果非空，则赋给对象的属性
                             if (value != DBNull.Value)
                             {
                                 //如果有枚举项
                                 if (dEnum != null)
                                 {
                                     var queryResult = from n in dEnum
                                                       where n.Key == tempName
                                                       select n;
                                     //枚举集合中包含与当前属性名相同的项
                                     if (queryResult.Count() > )
                                     {
                                         if (obj != null)
                                         {
                                             //将字符串转换为枚举对象
                                             pi.SetValue(obj, Enum.Parse(queryResult.FirstOrDefault().Value, value.ToString()), null);
                                         }
                                         else
                                         {
                                             //将字符串转换为枚举对象
                                             pi.SetValue(t, Enum.Parse(queryResult.FirstOrDefault().Value, value.ToString()), null);
                                         }
                                     }
                                     else
                                     {
                                         if (obj != null)
                                         {
                                             pi.SetValue(obj, value, null);
                                         }
                                         else
                                         {
                                             pi.SetValue(t, value, null);
                                         }
                                     }
                                 }
                                 else {
                                     if (obj != null)
                                     {
                                         pi.SetValue(obj, value, null);
                                     }
                                     else
                                     {
                                         pi.SetValue(t, value, null);
                                     }
                                 }
                             }
                         }
                     }
                     T ta = default(T);
                     //拆箱
                     if (obj != null)
                     {
                         ta = (T)obj;
                     }
                     else
                     {
                         ta = t;
                     }
                     //对象添加到泛型集合中
                     ts.Add(ta);
                 }
                 return ts;
             }
             else
             {
                 throw new ArgumentNullException("转换的集合为空.");
             }
         }

         /// <summary>
         /// 泛型集合转换成DataTable
         /// </summary>
         /// <typeparam name="T">泛型集合类型</typeparam>
         /// <param name="list">泛型集合对象</param>
         /// <returns></returns>
         public static DataTable ListGenuricConvertToDataTable<T>(List<T> list)
         {
             if (list?.Count > )
             {
                 Type type = typeof(T);
                 PropertyInfo[] properties = type.GetProperties();
                 DataTable dt = new DataTable(type.Name);
                 foreach (var item in properties)
                 {
                     dt.Columns.Add(new DataColumn(item.Name) { DataType = item.PropertyType });
                 }
                 foreach (var item in list)
                 {
                     DataRow row = dt.NewRow();
                     foreach (var property in properties)
                     {
                         row[property.Name] = property.GetValue(item, null);
                     }
                     dt.Rows.Add(row);
                 }
                 return dt;
             }
             else
             {
                 throw new ArgumentNullException("转换的集合为空.");
             }
         }
     }

下面是测试代码

     class Program
     {
         static void Main(string[] args)
         {
             DataTable dt = new DataTable();
             dt.Columns.Add("ID", typeof(int));
             dt.Columns.Add("Name", typeof(string));
             dt.Columns.Add("USex", typeof(string));
             dt.Rows.Add(, "肖潇",Sex.woman);
             dt.Rows.Add(, "何峰涛", Sex.man);
             dt.Rows.Add(, "王萌", Sex.woman);
             dt.Rows.Add(, "汤晓乐", Sex.man);
             Dictionary<string, Type> dEnum = new Dictionary<string, Type>();
             dEnum.Add("USex", typeof(Sex));
             List<User> liUser = (List<User>)Helper.DataTableConvertToListGenuric<User>(dt, dEnum);
             Console.WriteLine("DataTable To List<T>");
             foreach (var item in liUser)
             {
                 Console.WriteLine(item.ID + ":" + item.Name+":"+item.USex);
             }
             Console.WriteLine("================");
             DataTable dtConvert = Helper.ListGenuricConvertToDataTable(liUser);
             Console.WriteLine("List<T> To DataTable");
             foreach (DataRow item in dtConvert.Rows)
             {
                 Console.WriteLine(item["ID"] + ":" + item["Name"]+":"+(Sex)item["USex"]);
             }
             Console.ReadKey();
         }
     }

     struct User
     {
         public int ID { get; set; }
         public string Name { get; set; }
         public Sex USex { get; set; }
     }

     enum Sex {
         man = ,
         woman =
     }