DataSet装换为泛型集合 222

        #region DataSet装换为泛型集合

        /// <summary>  
        /// 利用反射和泛型  
        /// </summary>  
        /// <param name="dt"></param>  
        /// <returns></returns>  
        public static List<T> ConvertToList<T>(DataTable dt)
        {

            // 定义集合  
            List<T> ts = new List<T>();

            // 获得此模型的类型  
            Type type = typeof(T);
            //定义一个临时变量  
            string tempName = string.Empty;
            //遍历DataTable中所有的数据行  
            foreach (DataRow dr in dt.Rows)
            {
                T t = (T)Activator.CreateInstance(typeof(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)
                            //pi.SetValue(t, value, null);
                            pi.SetValue(t, DynamicConvert(value, pi.PropertyType));
                    }
                }
                //对象添加到泛型集合中  
                ts.Add(t);
            }

            return ts;

        }

        /// <summary>
        /// 通用转换方法，尽可能将值转换成目标类型
        /// </summary>
        public static object DynamicConvert(object value, Type type)
        {
            if (value == null && type.IsGenericType) return Activator.CreateInstance(type);
            if (value == null) return null;
            if (type == value.GetType()) return value;
            if (type.IsEnum)
            {
                if (value is string)
                    return Enum.Parse(type, value as string);
                else
                    return Enum.ToObject(type, value);
            }
            if (!type.IsInterface && type.IsGenericType)
            {
                if (value.GetType() == typeof(string) && Convert.ToString(value) == "")
                {
                    return null;
                }

                //DBNULL则返回null回去
                if (Convert.IsDBNull(value))
                {
                    return null;
                }

                Type innerType = type.GetGenericArguments()[0];
                object innerValue = DynamicConvert(value, innerType);
                return type.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { innerValue });
            }

            //如果是值类型，而且当前值是空字符串，或者是DBNULL，那么返回默认值
            if (type.IsValueType && (value.GetType() == typeof(string) && Convert.ToString(value) == "") ||
                Convert.IsDBNull(value))
            {
                return type.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });
            }
            //if (value is string && type == typeof(Guid)) return new Guid(value as string);
            //if (value is string && type == typeof(Version)) return new Version(value as string);
            if (!(value is IConvertible)) return value;
            return Convert.ChangeType(value, type);
        }

        /// <summary>
        /// 通用转换方法，尽可能将值转换成目标类型
        /// </summary>
        public static T DynamicConvert<T>(object value)
        {
            T result = (T)DynamicConvert(value, typeof(T));
            return result;
        }

       #endregion