C#反射与特性使用简介

本文是学习特性与反射的学习笔记，在介绍完特性和反射之后，会使用特性与反射实现一个简单的将datatable转换为list的功能，水平有限，如有错误，还请大神不吝赐教。

1.      反射：什么是反射？反射就是在程序运行的过程中，动态的获取类的成员，并对他们进行操作。包括动态调用方法，动态获取，设置属性等。通过特性，也能是想ioc，aop等功能。

2.      特性：特性只有在使用反射的时候才能发挥它最大的作用，通过反射获取到自定义的特性，再根据特性进行操作，例如在通过反射实现orm的时候，如果一个熟悉设置了不需要orm的特性，则可以忽略该属性。如果没有反射，那么可以把特性当做注释，它不会对代码的运行造成任何影响。但它和注释的区别在于，它会被编译进程序集，这样才能通过反射获取到这些特性。

3.      下面先演示反射的用法，反射常用的类有assembly，activator，type这几个类

assembly获取程序集应用，可以通过load，loadfile，loadfrom这几个方法将dll文件加载进当前程序集。如果需要反射的类位于当前程序集，则可以不使用此类

activator用于动态的创建一个类的实例，通过assembly加载的程序集，可以获取到它内部的所有的type，而activator.crea  teinstance方法可以为当前对象创建一个实例。（assembly也有createinstance方法用于创建类的实例）。

type表示一个类型，也可以通过typeof获取例如typeof（int）得到的就是int类型，然后type对象有很多的方法可以获取对象的成员，包括字段，方法，属性等等对象内部的所有都可以通过type获得。

下面是使用反射的示例

3.1、       添加一个新的类库，添加下面的代码，并生成为一个dll文件

 using system;

using system.collections.generic;

using system.linq;

using system.text;

using system.threading.tasks;

 

namespace refleatordll

{

    /// <summary>

    /// 此类用于反射获取到的对象的测试类

    /// 通过反射获取的类,不需要是public的，即使是private的类也是可以获取到的

    /// 类内部的所有成员,即使是private的，全部可以通过反射进行更改，但强烈不建议那样做，私有成员之所以为私有的，一定有必要的原因，

    /// 对私有成员的修改可能对类的运行造成难以预料的影响

    /// </summary>

    public class customclass

    {

        //用于反射的字段，包括私有，公有，静态字段用于演示不同的字段如何修改

        //下方的属性相同

        private string _name = null;

        public int _age = 0;

        public static string _address = null;//静态字段不设置属性，如有必要也可以设置

 

        public string name { get { return _name; } set { _name = value; } }

        public int age { get { return _age; } set { _age = value; } }

 

        //用于反射获取和调用类的方法

        //只包括静态和公有方法私有方法的获取请参考私有字段的获取

        //方法也包括有返回值与如返回值

        //其他情况的方法，请举一反三去获取

        public string getname()

        {

            return _name;

        }

 

        public static void showage(string name,int age)

        {

            console.writeline($"{name}'s age is :" + age);

        }

 

    }

}

3.2、       在主程序中通过反射对此类进行操作

 string path = path.combine(appdomain.currentdomain.basedirectory, "refleatordll.dll");

            assembly asm = assembly.loadfile(path);//加载程序集

 

            //asm.gettype方法与gettypes的区别在于，前者通过指点类型的名称获取指定的type，后者会获取到当前程序集中的所有类

            //类型名使用fullname

            type cs = asm.gettype("refleatordll.customclass");

 

            //为当前type创建一个实例

            //此方法有很多的重载，可以结合实际情况选择使用哪一个重载

            object obj = activator.createinstance(cs);

 

            //获取及修改私有的字段

            //如果是通过new的到的对象，私有字段是不能获取及修改的，但是通过反射就可以，同理属性，方法也是一样

            //bindingflags用于设置指定类型的字段，包括私有的，公有的，静态的，继承的，非继承的，等类型

            //下面的方法只获取公有的，静态的，非公有的，如果不知道则默认获取公有字段

            fieldinfo[] fis = cs.getfields(bindingflags.static|bindingflags.nonpublic|bindingflags.public|bindingflags.instance);

 

            fieldinfo fi = cs.getfield("_name", bindingflags.instance | bindingflags.nonpublic);

            //如果是实例字段，则需要将上面创建的obj传入，如果是静态字段则传入null即可

            console.writeline(fi.getvalue(obj).tostring());//显示当前值,当前显示为""

            fi.setvalue(obj, "此坑已满");

            console.writeline(fi.getvalue(obj).tostring());//显示当前值,显示为设置的值

 

            console.writeline("方法执行完毕!");

            console.readkey();

显示结果为：

 

属性的操作与字段操作相同只是将fieldinfo换为propertyinfo即可

下面演示方法的调用

创建对象的方法上面的实例已经有了，所以此处只附调用方法的代码

//带返回值的方法

            //如果是重载方法的话,需要在参数2中指定需要使用的方法的参数对应的数量和类型

            methodinfo mis = cs.getmethod("getname", bindingflags.instance|bindingflags.public);

            //参数2指定传入的参数数组如果当前执行的方法没有参数则传入null即可

            object returnvalue = mis.invoke(obj, null);

            console.writeline(returnvalue);//由于上面设置了_name的值,所以此处显示设置的值

//静态方法

            methodinfo miss = cs.getmethod("showage", bindingflags.static | bindingflags.public);

            miss.invoke(null, new object[] { "此坑已满", 26 });

 

执行结果

 

 

以上就是反射的简单使用方法,下面是反射结合特性的方法

1.      定义一个自定义的特性，.net框架自带很多的特性，如果写过wcf或者mvc就会有深刻的体验，比[required]，[httpget]等

  //attributeusage特性用于自定义特性，它用于设置特性的作用范围

    //例如此特性就只能用在方法上，已经特性是否可以多次使用，是否继承父类的特性等

    //自定义特性约定为{name}+attribute,当然也可以不加attribute

    //区别在于加后在使用时可以不加attribute否则就必须输入特性的全名

    //例如showattribute使用时只需要使用[show]即可

    //自定义特性必须继承自attribute类

    [attributeusage(attributetargets.method)]

    public class showattribute : attribute

    {

        public showattribute(string methodname)

        {

            console.writeline("您通过特性找到了方法:" + methodname);

        }

}

2.定义一个类并添加此特性

//此类用于演示showattribute特性

    public class showatttest

    {

        [show("showmethod")]

        public void showmethod()

        {

            //因为此方法只是用来测试特性的功能的,所以不做具体业务处理,直接返回

            return;

        }

}

3.通过反射调用此方法

  //反射特性测试,用于测试静态方法获取自定义特性与使用实例方法获取自定义特性是否执行特性内部方法的差别

            type t = typeof(showatttest);

            methodinfo mi = t.getmethod("showmethod");

            //通过反射的实例方法获取自定义特性,此方法会造成特性的代码被执行

            mi.getcustomattribute(typeof(showattribute));

 

            //通过静态方法获取自定义特性,此方法不会执行特性的代码

            //customattributedata.getcustomattributes(mi);

运行结果：

 

以上就是反射和特性的基础知识了，下面使用反射和特性实现一个简单的

将datatable转换为实体类

获取到的datatable的数据

 

转换后的数据请自行调试

 

示例源码

1.      自定义的特性

  //此特性仅用于忽略字段标识,同时设置为只能为属性添加

    [attributeusage(attributetargets.property)]

    public class ingoreattribute:attribute

    {

}

//此特性用于设置当前属性对应的数据库字段的名称

    [attributeusage(attributetargets.property)]

    public class columnnameattribute : attribute

    {

        public string name;//用于保存字段的名称

        public columnnameattribute(string name)

        {

            name = name;

        }

 }

2.      自定义实体

  //此类模拟一个实体类

    public class customentity

    {

        public int id { get; set; }

        public string name { get; set; }

        [columnname("telephone")]//设置phone的字段为telephone

        public string phone { get; set; }

        public string email { get; set; }

        [ingore]//忽略此字段,不从datatable中获取

        public string ingoretest { get; set; }

 }

3.      转换类

  //此类用于转换datatable到list

    public class converttolist

    {

        /// <summary>

        /// 实际转换的方法--约束泛型参数t只能是应用类型，同时必须包含一个无参构造函数

        /// </summary>

        /// <typeparam name="t"></typeparam>

        /// <returns></returns>

        public list<t> getlist<t>(datatable datatable) where t : class, new()

        {

            list<t> list = new list<t>();

            type type = typeof(t);

            //获取当前的实体的所有公共属性

            propertyinfo[] pis = type.getproperties(bindingflags.public | bindingflags.instance);

            foreach(datarow row in datatable.rows)

            {

                t t = new t();//创建一个实例

                foreach (var item in pis)

                {

                    //如果属性设置了ingore特性,则直接跳过此属性

                    attribute ingore = item.getcustomattribute(typeof(ingoreattribute));

                    if (ingore != null)

                    {

                        continue;

                    }

                    string fieldname = item.name;//取出属性的默认名字当做字段默认名

                    columnnameattribute columnname = item.getcustomattribute(typeof(columnnameattribute)) as columnnameattribute;

                    //如果当前属性添加了columnname特性,则设置字段名为name

                    if (columnname != null)

                    {

                        fieldname = columnname.name;

                    }

                    //由于演示的关系此处只添加了int类型的转换

                    if (item.propertytype == typeof(int))

                    {

                        item.setvalue(t, convert.toint16(row[fieldname].tostring()));//为当前属性赋值*注意此处可能存在装箱拆箱的问题

                    }

                    else

                    {

                        item.setvalue(t, row[fieldname]);

                    }

                }

                list.add(t);

            }

            return list;

        }

}

4.      测试代码

  //converttolist测试

            //此处模拟从数据库获取的数据,实际项目中请从真实的数据库获取数据

            datatable dt = new datatable();

            dt.columns.add("id");

            dt.columns.add("name");

            dt.columns.add("telephone");

            dt.columns.add("email");

            dt.columns.add("ingoretest");//此字段为忽略字段,列添加此字段只是为了演示转换过程中确实会忽略该字段

 

            datarow dr1 = dt.newrow();

            dr1["id"] = 1;

            dr1["name"] = "张三";

            dr1["telephone"] = "123456";

            dr1["email"] = "[e-mail]";

            dr1["ingoretest"] = "ingore";

            dt.rows.add(dr1);

 

            datarow dr2 = dt.newrow();

            dr2["id"] = 2;

            dr2["name"] = "李四";

            dr2["telephone"] = "456789";

            dr2["email"] = "[e-mail]";

            dr2["ingoretest"] = "ingoretest";

            dt.rows.add(dr2);

 

            converttolist ct = new converttolist();

        list<customentity> customs = ct.getlist<customentity>(dt);

以上就是通过反射和特性实现转换的功能，更多用法请参考相关教程，谢谢！