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 > 0)
            {
                // 定义集合 
                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() > 0)
                                    {
                                        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 > 0)
            {
                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(1, "肖潇",Sex.woman);
            dt.Rows.Add(2, "何峰涛", Sex.man);
            dt.Rows.Add(3, "王萌", Sex.woman);
            dt.Rows.Add(4, "汤晓乐", 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 = 0,
        woman = 1
    }