Table和List通过反射类型相互转化

        /// <summary>
        /// Datatable向list之间的转化
        /// </summary>
        /// <typeparam name="T">泛型类</typeparam>
        /// <param name="dt">数据源</param>
        /// <returns></returns>
        public List<T> GetObjectList<T>(DataTable dt) where T : new()
        {
            //定义泛型默认值
            T model = default(T);
            //定义接收集合
            List<T> dataList = null;
            //验证数据源是否有数据
            if (dt.Rows.Count > 0)
            {
                //实例化集合
                dataList = new List<T>();
                //循环每行结果
                foreach (DataRow dr in dt.Rows)
                {
                    //实例化泛型
                    model = new T();
                    //遍历泛型类中的所有属性
                    foreach (PropertyInfo pi in model.GetType().GetProperties())
                    {
                        //验证属性名是否等于列名
                        if (dr.Table.Columns.Contains(pi.Name))
                        {
                            //验证获取的值是否为null
                            object objvalue = dr[pi.Name];
                            if (objvalue.GetType() != typeof(System.DBNull))
                            {
                                pi.SetValue(model, objvalue);
                            }
                        }
                    }
                    dataList.Add(model);
                }
            }
            return dataList;
        }
        /// <summary>
        /// List向dataTable之间的转化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public DataTable GetObjectTable<T>(List<T> list) where T : new()
        {
            //定义泛型默认值
            T t = default(T);
            //定义接收Table
            DataTable dt = null;
            //验证集合是否有数据
            if (list.Count > 0)
            {
                //实例化DataTable
                dt = new DataTable();
                foreach (T model in list)
                {
                    //创建行
                    DataRow dr = dt.NewRow();
                    //接收泛型结果
                    t = model;
                    foreach (PropertyInfo pi in t.GetType().GetProperties())
                    {
                        //实例化列并声明列名和类型
                        if (dt.Columns.Count <= 0 || !dt.Columns.Contains(pi.Name))
                        {
                            DataColumn dc = new DataColumn(pi.Name, pi.PropertyType);
                            dt.Columns.Add(dc);
                        }
                        //向指定行中的指定列传入值
                        dr[pi.Name] = pi.GetValue(t);
                    }
                    dt.Rows.Add(dr);
                }
            }
            return dt;
        }
        static void Main(string[] args)
        {
            //调用方式
            DataTable table = new DataTable("tb");
            DataColumn dc1 = new DataColumn("Name", typeof(string));
            DataColumn dc2 = new DataColumn("Age", typeof(System.Int32));
            DataColumn dc3 = new DataColumn("BirthDay", typeof(DateTime));
            table.Columns.Add(dc1);
            table.Columns.Add(dc2);
            table.Columns.Add(dc3);
            string[] strNames = { "张三", "李四", "王五", "赵六" };

            for (int i = 0; i < strNames.Length; i++)
            {
                DataRow dr = table.NewRow();
                dr[dc1] = strNames[i];
                dr[dc2] = i + 20;
                dr[dc3] = DateTime.Now;
                table.Rows.Add(dr);
            }
            List<Test> list = new DataChange().GetObjectList<Test>(table);
            DataTable dt = new DataChange().GetObjectTable<Test>(list);
            Console.WriteLine(dt);
            Console.ReadLine();
        }

以上方式实现较简单，如有需要可自行调整