利用泛型和反射.递归将数据集中的数据添加到集合中

现在数据库一张表student,其中有属性若干,映射到C#代码中有Student_Model类,sql语句:"select * from student"(仅做测试).

public class Student_Model
    {
        public int StudentNo { get; set; }
        public string LoginPwd { get; set; }
        public string StudentName { get; set; }
        public bool Sex { get; set; }
        public int GradeID { get; set; }
        public string Phone { get; set; }
        public string Address { get; set; }
        public DateTime BornDate { get; set; }
        public string Email { get; set; }
        public string IdentityCard { get; set; }
    }

然后通过ADO.Net读取数据,将读取到的数据存入DataSet中,这个时候,问题来了,我们传统的方式是用循环逐行添加,比如:

List<Student_Model> students = ...; //这里获得Student_Model List<T>对象
DataSet ds =...;//这里获得ds对象,已存储完数据
foreach(DataRow row in ds.Tables[0].Rows)
{
    students.Add(
        new Student_Model{
            StudentNo = item["studentno"].ToInt32(),
            LoginPwd = item["LoginPwd"].ToString(),
            StudentName = item["StudentName"].ToString(),
            Sex = item["Sex"].ToBoolean(),
            GradeID = item["GradeID"].ToInt32(),
            Phone = item["Phone"].ToString(),
            Address = item["Address"].ToString(),
            BornDate = item["BornDate"].ToDateTime(),
            Email = item["Email"].ToString(),
            IdentityCard = item["IdentityCard"].ToString(),
        }
    );
}

其中ToInt32()等方法,均在其他类中重写,最后将会补上重写代码;

从上面的遗传代码可以看出,数据可以成功添加进集合中,但是,当我们利用抽象工厂调用不同数据库的时候的时候,同一个方法要写几遍,又或者,你需要编写很多个查询方法,并依次将ds对象插入数据集中,又或者,你这个对象中有100个属性,甚至是1000个...

这个时候,我们需要封装和复用代码...

但你说,我能用复制粘贴,好吧,那么你可以关闭这个网页了...

抽取这个方法不失为一个好方法,具体怎么做呢?

将要复用的代码抽取到一个方法中,比如,上一个代码块中的整个foreach循环,很明显,这个将是我们要大量复用的.

简单的抽取肯定不行,这时候我们需要用到泛型,反射,和递归来完成一个无可匹敌的公共方法,这个方法可查询所有对象,包括对象中包含的自定义对象,比如,Student_Model包含一个年级类Grade_Model.

步骤如下:

创建一个泛型类,如DataSetToList<T>:

public class DataSetToList<T>
    {
        
    }

在这个类中添加方法:

public List<T> GetList(DataSet ds, int TableIndex)
        {
            List<T> lists = new List<T>();
            foreach (DataRow item in ds.Tables[TableIndex].Rows)
            {
                //代码
            }
            return lists;
        }

我们将要在这里面完成封装和复用,将代码修改如下:

public List<T> GetList(DataSet ds, int TableIndex)
        {
            List<T> lists = new List<T>();
            foreach (DataRow item in ds.Tables[TableIndex].Rows)
            {
                T t = Activator.CreateInstance<T>();//创建泛型类的实例
                foreach(PropertyInfo p in t.GetType().GetProperties()){
                    p.SetValue(t,item[p.Name],null);
                }
                lists.Add(t);
            }
            return lists;
        }

我们分析一下以上代码,首先创建了一个集合,这个集合最后要作为结果返回;然后循环参数DataSet的ds对象的行;

其中我们要注意的是,如何创建泛型对象,T t = Activator.CreateInstance<T>();

关于Activator类,MSDN中的解释是:包含特定的方法,用以在本地或远程创建对象模型,此类不能被继承.该类的签名是public class seald Activator:_Activator ;命名空间是System;

关于Activator.CreateInstance<T>()方法,MSDN的描述是:使用无参构造函数,创建指定泛型类型参数所指定类型的实例. 这句话听起来有点拗口,其实就是创建当前泛型类的对象,创建方式是无参构造函数. 该方法的签名是public static T CreateInstance<T>();

好了,到这里为止,我们创建了对象,但是还没有对对象赋值,此时就应该遍历泛型类的所有公共属性;

泛型类的公共属性由泛型类的对象t的GetType()方法来获得t的当前实例的Type,Type在MSDN中的描述是:表示类型声明:类类型,接口类型,数组类型,值类型,枚举类型,类型参数,泛型类型定义,以及开放或封闭构造的泛型类型. 该Type类的签名是public abstract class Type : MemberInfo, _Type, IReflect

然后再调用该类型的GetProperties()方法来获得所有公共属性,返回一个数组;p.SetValue(参数1:其属性值的对象, 参数2:新的属性值, 参数3:索引化属性的可选索引值).该方法签名是:public virtual void SetValue(Object obj,Object value,Object[] index);

至此,我们算是完成一个简单的,比如"select * from student"的语句查询,没有问题,但是,一旦我们将Student_Model类稍作修改呢?

public int StudentNo { get; set; }
        public string LoginPwd { get; set; }
        public string StudentName { get; set; }
        public bool Sex { get; set; }
        public int GradeID { get; set; }
        public string Phone { get; set; }
        public string Address { get; set; }
        public DateTime BornDate { get; set; }
        public string Email { get; set; }
        public string IdentityCard { get; set; }
        //年级
      public Grade_Model Grade { get; set; }
}

我们添加了第十二行,为此,添加一个Grade_Model的类:

public class Grade_Model
    {
        public int GradeID { get; set; }        //年级编号
        public string GradeName { get; set; }   //年级名称
    }

那么同样是上面那个所谓的通用方法,到这里,是否还会适用么?

结果是System.ArgumentException:列"Grade"不属于表Table异常;所以我们还要稍作修改:

public class DataSetToList<T>
    {
        public List<T> GetList(DataSet ds, int TableIndex)
        {
            List<T> lists = new List<T>();
            foreach (DataRow item in ds.Tables[TableIndex].Rows)
            {
                T t = Activator.CreateInstance<T>();//创建泛型类的实例
                foreach(PropertyInfo p in t.GetType().GetProperties()){
                    //判断是否系统类型
                    if (p.PropertyType.ToString().StartsWith("System."))
                    {
                        p.SetValue(t, item[p.Name], null);
                    }
                    else
                    {
                        //如果不是，则...
                    }
                }
                lists.Add(t);
            }
            return lists;
        }
    }

我们添加了一行if判断,当他是系统类型的时候正常赋值,如果不是,则需要写新的代码;

属性PropertyInfo的类型是用其属性PropertyType来获取,而不是GetType(),GetType()是获取当前属性的对象实例的Type;

显然,如果不是系统类型那么肯定是自定义的,如Grade_Model,在这里,我们要考虑到Grade_Model类中是否还有第三个类,比如Subject_Model课程信息类;

public List<T> GetList(DataSet ds, int TableIndex)
        {
            List<T> lists = new List<T>();
            foreach (DataRow item in ds.Tables[TableIndex].Rows)
            {
                T t = Activator.CreateInstance<T>();//创建泛型类的实例
                GetT(item,t);
                lists.Add(t);
            }
            return lists;
        }

        public void GetT(DataRow row,Object obj)
        {
            foreach (PropertyInfo p in obj.GetType().GetProperties())
            {
                if (p.PropertyType.ToString().StartsWith("System."))
                {
                    if(row.Table.Columns.Contains(p.Name)){
                        p.SetValue(obj,row[p.Name],null);
                    }
                }
                else
                {
                    Object o = p.PropertyType.Assembly.CreateInstance(p.PropertyType.ToString());
                    GetT(row, o);
                    p.SetValue(obj,o,null);
                }
            }
        }

至此,这个代码才算完整,基本能应对各种查询带来的ds转化,当然,代码要注意实体类主外键映射;

我们分析一下以上写的代码:

我们抽取了一个GetT()的方法,参数是DataSet类型和Object类型;

第19行,row.Table.Columns.Contains(p.Name),判断数据库列是否包含属性名称,如果是,则添加数据,否则返回继续;

第23行开始, 是当该公共属性是一个自定义类型的时候,我们重新创建一个Object,该Object由属性的对象,先获得PropertyType属性,然后获得该属性类型所在的程序集,并创建该属性类型的对象,所以参数是p.PropertyType.ToString();

最后,提下重写ToInt32()方法:

    public static class ToolHelper
    {
        #region Convert Method
        public static Int32 ToInt32(this Object obj)
        {
            return Convert.ToInt32(obj);
        }
        public static Int16 ToInt16(this Object obj)
        {
            return Convert.ToInt16(obj);
        }
        public static Int64 ToInt64(this Object obj)
        {
            return Convert.ToInt64(obj);
        }
        public static bool ToBoolean(this Object obj)
        {
            return Convert.ToBoolean(obj);
        }
        public static DateTime ToDateTime(this Object obj)
        {
            return Convert.ToDateTime(obj);
        }
        public static double ToDouble(this Object obj)
        {
            return Convert.ToDouble(obj);
        }
        #endregion
}

到这里,该知识点就基本介绍完了...