反射介绍

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
}