反射

一、定义

反射是一种 通过动态读取程序集，获取其中的类型元数据，并且对其进行访问的 技术。

二、用法

首先创建一个Person类。

public class Person
    {
        private int _size;
        public string Name { get; set; }
        public int Age { get; set; }
        public int Gender { get; set; }
        public void Say()
        {
            Console.WriteLine("hello !");
        }

        public void SayHello()
        {
            Console.WriteLine("hello ,everyone !");
        }

        void Introduce()
        {
            Console.WriteLine("i am wesley");
        }
    }

1.Type对象

接下来使用反射中的重要对象Type访问Person中的类型元数据。使用Type对象，有两种方式。

第一种方式：Type personType = typeof(Person);

Type personType = typeof(Person);
            MemberInfo[] members = personType.GetMembers();
            for (int i = 0; i < members.Length; i++)
            {
                Console.WriteLine(members[i].Name);
            }

输出结果：

//get_Name
            //set_Name
            //get_Age
            //set_Age
            //get_Gender
            //set_Gender
            //Say
            //SayHello
            //ToString
            //Equals
            //GetHashCode
            //GetType
            //.ctor
            //Name
            //Age
            //Gender

包括编译器自动生成的与属性对应的方法，继承自object的方法，但是不包括私有方法。如果需要访问私有方法，需要用其他方式。

第二种方式： Person person = new Person();  Type personType= person.GetType();

 Person person = new Person();
            Type personType= person.GetType();

            //获取所有方法,私有的方法不能获取
            MethodInfo[] methods = personType.GetMethods();
            for (int i = 0; i < methods.Length; i++)
            {
                Console.WriteLine(methods[i].Name);
            }

            //所有属性
            PropertyInfo[] properties=  personType.GetProperties();
            for (int i = 0; i < properties.Length; i++)
            {
                Console.WriteLine(properties[i].Name);
            }

用Type对象还能访问其他类型元数据，具体可以查看文档或者对象中的成员。

2.Assembly

先创建一个类库，里面有类，接口，委托等，代码如下：

namespace _01TestDLL
{
    class Test
    {
    }

    public class Person
    {
        private int _size;
        public string Name { get; set; }
        public int Age { get; set; }
        public int Gender { get; set; }
        public void Say()
        {
            Console.WriteLine("hello !");
        }

        public void SayHello()
        {
            Console.WriteLine("hello ,everyone !");
        }

        void Introduce()
        {
            Console.WriteLine("i am wesley");
        }

        public int Add(int n1,int n2)
        {
            return n1 + n2;
        }

        //public int Add(int n1, int n2,int n3)
        //{
        //    return n1 + n2 + n3;
        //}
    }

    class MyClass
    { }

    public delegate void M1Delegate();

    delegate void M2Delegate();

    interface IDriveAble { }

    public interface IFlyAble
    {
        void Fly();
    }

    public class Student
    {

    }

    public class Teacher : IFlyAble
    {
        public void Fly()
        {
            Console.WriteLine("i can fly ,see me fly high !");
        }
    }
}

把上面的类库生成dll，用Assembly读取。

显示dll中的所有类型元数据：

  Assembly assembly = Assembly.LoadFile(@"F:\BaseWork\01TestDLL\bin\Debug\01TestDLL.dll");

            //Console.WriteLine(assembly.GetType().Name);

            //这种方式输出程序集中的所有类型元数据
            Type[] types1 = assembly.GetTypes();
            foreach (var item in types1)
            {
                Console.WriteLine(item.Name);
            }

            //只显示public的类型元数据
            Type[] types = assembly.GetExportedTypes();
            foreach (var item in types)
            {
                Console.WriteLine(item.Name);
            }

 访问Person类中无参无返回值的Say方法：

#region 调用程序集中无参无返回值的方法
            Type personType = assembly.GetType("_01TestDLL.Person");

            MethodInfo method = personType.GetMethod("Say");

            object obj = Activator.CreateInstance(personType);

            //我们不能直接创建要调用的方法所在的类的对象（如果可以创建对象，我们直接可以调用该类中的方法了，没必要再用反射），所以用上一行代码创建对象
            method.Invoke(obj, null);//第一个参数：当前要调用的方法所在的类的对象；第二个参数：要调用的方法的参数列表
            #endregion

调用Person类中有参数有返回值的方法（Add(int n1,int n2)）：

#region 调用程序集中有参数有返回值的方法
            Type personType = assembly.GetType("_01TestDLL.Person");

            MethodInfo method = personType.GetMethod("Add");
            object obj = Activator.CreateInstance(personType);
            int res = (int)method.Invoke(obj, new object[] { 1, 2 });
            Console.WriteLine(res);
            #endregion

调用Person类中Add的重载方法（Add(int n1,int n2，int n3)）：

#region 调用程序集中重载的方法
            //如果Add方法有重载，则需要区分方法是否重载
            Type personType = assembly.GetType("_01TestDLL.Person");
            MethodInfo method = personType.GetMethod("Add", new Type[] { typeof(int), typeof(int), typeof(int) });
            object obj = Activator.CreateInstance(personType);
            int res = (int)method.Invoke(obj, new object[] { 1, 2, 3 });
            Console.WriteLine(res);
            #endregion

 给属性赋值，取值

#region 给属性赋值，并且取值
            Type personType= assembly.GetType("_01TestDLL.Person");
            PropertyInfo proper= personType.GetProperty("Name");
            //object obj= assembly.CreateInstance("_01TestDLL.Person");//和下面的代码效果一样
            object obj = Activator.CreateInstance(personType);
            proper.SetValue(obj, "张三");

            string name= proper.GetValue(obj, null).ToString(); ;
            Console.WriteLine(name);
            #endregion

先在Person类中添加一个方法和构造函数，然后调用构造函数，创建对象

方法和构造函数

public Person(string name,int age)
        {
            this.Name = name;
            this.Age = age;
        } 

public void GetPropertiesValue()
        {
            Console.WriteLine(this.Name+"   "+this.Age);
        }

调用构造函数，创建对象

 #region 调用构造函数，创建对象
            Type typePerson = assembly.GetType("_01TestDLL.Person");
            ConstructorInfo ctor = typePerson.GetConstructor(new Type[] { typeof(string), typeof(int) });

            object obj= ctor.Invoke(new object[] { "张三", 18 });

            MethodInfo method= typePerson.GetMethod("GetPropertiesValue");
            method.Invoke(obj, null);

            #endregion

3.Type的其他常用方法和属性

先创建类和获取程序集：

namespace _02TestDLL
{
    public class Person
    {
        public void Introduce()
        {
            Console.WriteLine("我是人类");
        }
    }

    public interface IFlyAble
    {
        void Fly();
    }

    public abstract class MyAbstractClass
    {

    }

    public static class MyStaticClass
    {

    }

    public class Student : Person, IFlyAble
    {
        public void Fly()
        {
            throw new NotImplementedException();
        }
    }
}

程序集：

Assembly assembly = Assembly.LoadFile(@"F:\BaseWork\02TestDLL\bin\Debug\02TestDLL.dll");

 IsAssignableFrom()：判断当前实例是不是可以接收传入的实例

Type typePerson = assembly.GetType("_02TestDLL.Person");

            Type typeStudent = assembly.GetType("_02TestDLL.Student");

            Type typeIFlyAble = assembly.GetType("_02TestDLL.IFlyAble");

            bool bPerson = typePerson.IsAssignableFrom(typeStudent);

            Console.WriteLine(bPerson);

            //输出true

IsInstanceOfType()：判断指定的实例是不是当前类型的实例

 Type typePerson = assembly.GetType("_02TestDLL.Person");
            Type typeStudent = assembly.GetType("_02TestDLL.Student");
            Object obj = Activator.CreateInstance(typeStudent);

            bool b = typePerson.IsInstanceOfType(obj);
            Console.WriteLine(b);
            //输出true

IsSubclassOf()：判断当前Type表示的类是不是从指定的类派生的

 Type typePerson = assembly.GetType("_02TestDLL.Person");
            Type typeStudent = assembly.GetType("_02TestDLL.Student");
            bool b = typeStudent.IsSubclassOf(typePerson);
            Console.WriteLine(b);
            //输出true

IsAbstract：判断当前Type表示的类是不是抽象的，包括接口和静态类

Type typeMyStaticClass = assembly.GetType("_02TestDLL.MyStaticClass");
            Type typeMyAbstractClass = assembly.GetType("_02TestDLL.MyAbstractClass");
            Type typeIFlyAble = assembly.GetType("_02TestDLL.IFlyAble");

            bool b1 = typeMyStaticClass.IsAbstract;
            Console.WriteLine(b1);

            bool b2 = typeMyAbstractClass.IsAbstract;
            Console.WriteLine(b2);

            bool b3 = typeIFlyAble.IsAbstract;
            Console.WriteLine(b3);
            //输出true

 用IsAbstract属性判断时，发现静态类，接口也返回true，反编译后查看IL语言，发现静态类，接口其实就是抽象类。