/// <summary>

    /// 利用反射将DataTable转换为List<T>对象

    /// </summary>

    /// <param name="dt">DataTable 对象</param>

    /// <returns>List<T>集合</returns>

    public static List<T> DataTableToList<T>(DataTable dt) where T :class,new ()

    {

      // 定义集合

      List<T> ts = new List<T>();

      //定义一个临时变量

      string tempName = string.Empty;

      //遍历DataTable中所有的数据行

      foreach (DataRow dr in dt.Rows)

      {

        T t = new T();

        // 获得此模型的公共属性

        PropertyInfo[] propertys = t.GetType().GetProperties();

        //遍历该对象的所有属性

        foreach (PropertyInfo pi in propertys)

        {

          tempName = pi.Name;//将属性名称赋值给临时变量

          //检查DataTable是否包含此列（列名==对象的属性名）

          if (dt.Columns.Contains(tempName))

          {

            //取值

            object value = dr[tempName];

             //如果非空，则赋给对象的属性

             if (value != DBNull.Value)

             {

               pi.SetValue(t,value,null);

             }

          }

        }

        //对象添加到泛型集合中

        ts.Add(t);

      }

      return ts;

    }

 /// <summary>

        /// List转换成DataSet

        /// </summary>

        /// <typeparam name="T">类型</typeparam>

        /// <param name="list">将要转换的List</param>

        /// <returns></returns>

        public DataSet ConvertToDataSet<T>(IList<T> list)

        {

            if (list == null || list.Count <= )

            {

                return null;

            }

            DataSet ds = new DataSet();

            DataTable dt = new DataTable(typeof(T).Name);

            DataColumn column;

            DataRow row;

            System.Reflection.PropertyInfo[] myPropertyInfo = typeof(T).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);

            foreach (T t in list)

            {

                if (t == null)

                {

                    continue;

                }

                row = dt.NewRow();

                for (int i = , j = myPropertyInfo.Length; i < j; i++)

                {

                    System.Reflection.PropertyInfo pi = myPropertyInfo[i];

                    string name = pi.Name;

                    if (dt.Columns[name] == null)

                    {

                        column = new DataColumn(name, pi.PropertyType);

                        dt.Columns.Add(column);

                    }

                    row[name] = pi.GetValue(t, null);

                }

                dt.Rows.Add(row);

            }

            ds.Tables.Add(dt);

            return ds;

        }

private DataTable ToDataTable<T>(List<T> items)

        {

            var tb = new DataTable(typeof(T).Name);

            PropertyInfo[] props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

            foreach (PropertyInfo prop in props)

            {

                Type t = GetCoreType(prop.PropertyType);

                tb.Columns.Add(prop.Name, t);

            }

            foreach (T item in items)

            {

                var values = new object[props.Length];

                for (int i = ; i < props.Length; i++)

                {

                    values[i] = props[i].GetValue(item, null);

                }

                tb.Rows.Add(values);

            }

            return tb;

        }

        public static bool IsNullable(Type t)

        {

            return !t.IsValueType || (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>));

        }

        public static Type GetCoreType(Type t)

        {

            if (t != null && IsNullable(t))

            {

                if (!t.IsValueType)

                {

                    return t;

                }

                else

                {

                    return Nullable.GetUnderlyingType(t);

                }

            }

            else

            {

                return t;

            }

        }