单表查询结果转换成泛型集合

 /// <summary>
        /// 单表查询结果转换成泛型集合
        /// </summary>
        /// <typeparam name="T">泛型集合类型</typeparam>
        /// <param name="dt">查询结果DataTable</param>
        /// <returns>以实体类为元素的泛型集合</returns>
        public static IList<T> ConvertToList<T>(DataTable dt) where T : new()
        {
            // 定义集合
            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();
                // 获得此模型的公共属性
                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);

                            if (!pi.PropertyType.IsGenericType)
                            {
                                //非泛型
                                pi.SetValue(t, string.IsNullOrEmpty(value.ToString()) ? null : Convert.ChangeType(value, pi.PropertyType), null);
                            }
                            else
                            {
                                //泛型Nullable<>
                                Type genericTypeDefinition = pi.PropertyType.GetGenericTypeDefinition();
                                if (genericTypeDefinition == typeof(Nullable<>))
                                {
                                    pi.SetValue(t, string.IsNullOrEmpty(value.ToString()) ? null : Convert.ChangeType(value, Nullable.GetUnderlyingType(pi.PropertyType)), null);
                                }
                            }
                        }
                    }
                }
                //对象添加到泛型集合中
                ts.Add(t);
            }

            return ts;
        }

public static List<T> ToList<T>(this DataTable dt) where T : new()
        {
            List<T> list = new List<T>();
            T t;

            PropertyInfo[] pi = typeof(T).GetProperties();
            foreach (DataRow dr in dt.Rows)
            {
                t = new T();
                foreach (PropertyInfo parm in pi)
                {
                    if (dt.Columns.Contains(parm.Name))
                    {
                        parm.SetValue(t, Utility.ChangeType(dr[parm.Name], parm.PropertyType), null);
                    }
                }
                list.Add(t);
            }

            return list;
        }

/// <summary>
        /// 类型转换
        /// </summary>
        /// <param name="value">值</param>
        /// <param name="type">类型</param>
        /// <returns></returns>
        public static object ChangeType(object value, Type type)
        {
            Type oldType = type;
            if (value == null || value == DBNull.Value)
            {
                return type.IsValueType ? Activator.CreateInstance(type) : null;
            }
            // 若是可空类型, 则转为基类型
            if (type.IsGenericType && !type.IsGenericTypeDefinition && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                type = Nullable.GetUnderlyingType(type);
            }
            try
            {// Guid类型
                if (type == typeof(Guid))
                {
                    return new Guid(value.ToString());
                }
            }
            catch
            {
                if (oldType.IsGenericType)
                {
                    return null;
                }
                return Guid.Empty;
            }

            try
            {// 枚举类型
                if (type.IsEnum)
                {
                    return Enum.Parse(type, value.ToString());
                }
            }
            catch
            {
                return null;
            }

            try
            {// 其它类型直接转换
                return Convert.ChangeType(value, type);
            }
            catch
            {
                if (oldType.IsGenericType)
                {
                    return null;
                }
                return Activator.CreateInstance(type);
            }
        }

时间: 2024-10-06 13:41:55

单表查询结果转换成泛型集合的相关文章

django之数据库表的单表查询

一.添加表记录 对于单表有两种方式 # 添加数据的两种方式 # 方式一:实例化对象就是一条表记录 Frank_obj = models.Student(name ="海东",course="python",birth="2000-9-9",fenshu=80) Frank_obj.save() # 方式二: models.Student.objects.create(name ="海燕",course="python

ORM单表查询

django之数据库表的单表查询 一.添加表记录 对于单表有两种方式 # 添加数据的两种方式 # 方式一:实例化对象就是一条表记录 Frank_obj = models.Student(name ="海东",course="python",birth="2000-9-9",fenshu=80) Frank_obj.save() # 方式二: models.Student.objects.create(name ="海燕",co

第二章 单表查询 T-SQL语言基础(2)

单表查询(2) 2.2 谓词和运算符 T-SQL有几种不同的语言元素可以指定逻辑表达式,例如,查询过滤器(WHERE和HAVING),CHECK约束,等等. 在逻辑表达式中可以使用各种谓词(取值为TRUE,FALSE,或UNKNOWN的表达式)和运算符. T-SQL支持的谓词包括IN,BETWEEN,以及LIKE等. -- Predicates: IN, BETWEEN, LIKE SELECT orderid, empid, orderdate FROM Sales.Orders WHERE

数据库学习笔记系列(4)——单表查询_1

单表查询就是查询的范围只是一个table,我们对其中的某一个字段,或者多个字段进行查询返回,查询的时候还可以满足一定的条件. 下面我们就按照实际的问题,来学习一下单表查询. 首先,原始的是一个student表,其中有如下几个字段: 学号:snum 姓名:sname 年龄:sage 性别:ssex 院系:department 课程:course 分数:score create table student(snum int(5), sname varchar(10), sage int(5), ss

0x06 MySQL 单表查询

一 单表查询语法 SELECT 字段1,字段2... FROM 表名 WHERE 条件 GROUP BY field HAVING 筛选 ORDER BY field LIMIT 限制条数 二 关键字执行优先级(重点) 重点中的重点:关键字的执行优先级 1)from 2)where 3)group by 4)having 5)select 6)distinct 7)order by 8)limit 1.找到表:from 2.拿着where指定的约束条件,去文件/表中取出一条条记录 3.将取出的一

mysql四-1:单表查询

阅读目录 一 单表查询的语法 二 关键字的执行优先级(重点) 三 简单查询 四 WHERE约束 五 分组查询:GROUP BY 六 HAVING过滤 七 查询排序:ORDER BY 八 限制查询的记录数:LIMIT 九 使用正则表达式查询 一 单表查询的语法 SELECT 字段1,字段2... FROM 表名 WHERE 条件 GROUP BY field HAVING 筛选 ORDER BY field LIMIT 限制条数 二 关键字的执行优先级(重点) 重点中的重点:关键字的执行优先级 f

Mysql(四)-1:单表查询

一 单表查询的语法 SELECT 字段1,字段2... FROM 表名 WHERE 条件 GROUP BY field HAVING 筛选 ORDER BY field LIMIT 限制条数 二 关键字的执行优先级(重点) 重点中的重点:关键字的执行优先级 from where group by having select distinct order by limit 1.找到表:from 2.拿着where指定的约束条件,去文件/表中取出一条条记录 3.将取出的一条条记录进行分组group

DAY11-MYSQL单表查询

一 单表查询的语法 SELECT 字段1,字段2... FROM 表名 WHERE 条件 GROUP BY field HAVING 筛选 ORDER BY field LIMIT 限制条数 二 关键字的执行优先级(重点) 重点中的重点:关键字的执行优先级 from where group by having select distinct order by limit 详细见: http://www.cnblogs.com/guoyunlong666/p/8518811.html 三 简单查询

MySQL数据库篇之单表查询

主要内容: 一.单表查询的语法 二.关键字的执行优先级 三.简单查询 四.where约束 五.分组查询 group by 六.having过滤 七.查询排序 order by 八.限制查询的记录数 limit 九.使用正则表达式查询 1?? 单表查询的语法 SELECT 字段1,字段2... FROM 表名 WHERE 条件 GROUP BY field HAVING 筛选 ORDER BY field LIMIT 限制条数 2??  关键字的执行优先级 重点中的重点:关键字的执行优先级(从上至