反射介绍

        static void Main(string[] args)
        {
            #region 反射介绍
            //反射：通过动态获取程序集 获取其中的类型元数据 然后访问类型的过程
            //反射中一个非常重要的类型就是Type
           
            //1.如果获取Type类型的对象？
            //获取Person类型的Type 对象  Type 对象中就是存放了一些关于某个类型的所有的信息的内容
            //

            //1>当没有对象的时候使用这种方式获取某个类型的Type
            //Type type =typeof(Person);
            //2>//当获得对象后就可以使用对象的GetType() 方法来获取指定对象的类型的Type对象
            //Person p=new Person();
            //Type personType = p.GetType();
           
            ////2.获取Person类中的所有的方法
            //MethodInfo[] methods = personType.GetMethods();
            ////methods这个变量中存储了Person类中的所有的方法
            ////遍历输出每个方法的方法名
            //for (int i = 0; i < methods.Length; i++)
            //{
            //    //通过Type对象的GetMethods() 可以获取指定类型的所有的方法其中包括编译器自动
            //    //自动生成的以及从父类中继承来的方法 但是不包含private方法 需要使用其他方式

            //    Console.WriteLine(methods[i].Name);
            //}
            //Console.ReadKey();

           // //3.获取某个类型的所有属性
           //PropertyInfo[] properties= personType.GetProperties();

           //for (int i = 0; i < properties.Length; i++)
           //{
           //    Console.WriteLine(properties[i].Name);
           //}


           //获取类中所有字段
           //FieldInfo[] fields = personType.GetFields();
           //for (int i = 0; i < fields.Length; i++)
           //{
           //    Console.WriteLine(fields[i].Name);
           //}
          
           // Console.ReadKey();
            #endregion

            #region 反射获取另外一个程序集中类型
           
            //Assembly
            //动态加载一个程序集
            Assembly assembly = Assembly.LoadFile(@"c:\a.dll");

            //获取刚刚加载的程序集中的所有类型
            //assembly.GetType() 等价 typeof（Assembly）,不能获取某程序集中的所有类型

            //GetType()类获取了所有的类型
            //Type[] types = assembly.GetTypes();
           
            //只能获取那些public的类型
            //Type[] types = assembly.GetExportedTypes();
            //for (int i = 0; i <types.Length; i++)
            //{
            //    Console.WriteLine(types[i].Name );
            //}
           

            //只获取Person类的Type
            //GetType() 方法有重载 选择第二个重载  参数 表示是要获取的类型的“
            //"完全限定名称" 即 ：命名空间.类名
            //这里拿到了Type，其实就等价于typeof(Person) 或者是：p.GetType()
            Type personType = assembly.GetType("_TestDll.Person");

            //获取所有的方法 ：personType.GetMethods()*
           

            //获取某个特定的方法(根据方法名)：personType.GetMethod();

            #region 调用无参数的构造方法
            // MethodInfo method=  personType.GetMethod("SayHi");

            //  //通过反射来创建一个person类型的对象{其实就是通过Person的Type来创建一个
            //  //Person对象}

            //object objPerson = Activator.CreateInstance(personType);
            //  //调用这个方法
            //  //这个是无参数无返回值的参数
            //method.Invoke(objPerson,null );
            #endregion
            #region 调用带参数 带返回值的方法
           
         
            //调用带参数 带返回值的方法
            ////1>找到对应的方法
            //MethodInfo method = personType.GetMethod("Add");
            //object obj = Activator.CreateInstance(personType);
            ////2>调用
            //object result = method.Invoke(obj,new object[]{10,200});
            //Console.WriteLine("调用Add方法的返回值结果是：{0}",result);

            #endregion
            #region 调用带重载的方法
            //1>找到对应的方法
            //MethodInfo method = personType.GetMethod("Add", new Type[] { typeof(int), typeof(int), typeof(int) });
            //object obj = Activator.CreateInstance(personType);

            ////调用
            //int r = (int)method.Invoke(obj,new object[]{1,2,3});

            //Console.WriteLine(r);
            #endregion

            #region 通过反射获取类的属性 并赋值
            ////1获取属性
            //PropertyInfo property = personType.GetProperty("Name");
            //object obj = Activator.CreateInstance(personType);
            ////2为属性赋值
            //property.SetValue(obj,"王健",null);

            ////3获取属性
            ////string name = property.GetValue(obj,null ).ToString();
            ////Console.WriteLine(name);

            #endregion

            #region 手动查找类型的构造函数 并且调用该构造函数来创建类型的对象
         //   //找到对应的构造函数 但是还没有调用
         //ConstructorInfo ctor =  personType.GetConstructor(new Type[] { typeof(string), typeof(int ) });
         //   //开始调用构造函数
         //object obj = ctor.Invoke(new object[]{"hpp",16});
         //Console.WriteLine(obj.ToString());
            #endregion


            #region 其他的反射中的一些方法
            ///动态加载一个程序集
           
            //获取Person的Type
            Type typePerson = assembly.GetType("_02TestDll.Person");

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

            Type typeFlayable = assembly.GetType("_02TestDll.IFlyable");
            #region //bool IsAssignableFrorm(Type c):(直译：是否可以从c赋值)
            //判断当前的类型的变量是不是可以接受c类型的赋值

            //Student 是 Person的子类  所以这返回的是true
            //bool b = typePerson.IsAssignableFrom(typeStudent);

            //Console.WriteLine(b);
            #endregion

            #region    bool IsInstanceOfType (object o) :判断对象o 是否是当前的实例
            //（当前类可以是o 的类 父类 接口）

            ////Person
            //object objPerson = Activator.CreateInstance(typePerson);
            ////Student
            //object objStudent = Activator.CreateInstance(typeStudent);

            //bool b = typePerson.IsInstanceOfType(objPerson);//true

            //Console.WriteLine(b);

            #endregion

            #region bool IsSubclassof(Type c):判断当前类是类是否是c的子类

            bool b = typeStudent.IsSubclassOf(typeFlayable);
            Console.WriteLine(b);

            #endregion

            #region IsAbstract 判断是否为抽象的 含接口

            Console.WriteLine(typePerson.IsAbstract);//false
            #endregion





           
            #endregion
            Console.ReadKey();
            #endregion
        }