反射 | w.k's notes

1.简介

反射提供了封装程序集、模块和类型的对象（Type类型）。可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了特性，可以利用反射对它们进行访问。

2.反射的用途

（1）使用Assembly定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型并创建该类型的实例。
（2）使用Module了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。
（3）使用ConstructorInfo了解构造函数的名称、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
（4）使用MethodInfo了解方法的名称、返回类型、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
（5）使用FiedInfo了解字段的名称、访问修饰符（如public或private）和实现详细信息（如static）等，并获取或设置字段值。
（6）使用EventInfo了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型等，添加或移除事件处理程序。
（7）使用PropertyInfo了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等，获取或设置属性值。
（8）使用ParameterInfo了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。

3.反射涉及的类

1.Namespace

System.Reflection
System.Type
System.Reflection.Assembly

2. Class

System.Type 类－－通过这个类可以访问任何给定数据类型的信息。
System.Reflection.Assembly类－－它可以用于访问给定程序集的信息，或者把这个程序集加载到程序中。

3. System.Type 类

System.Type 类对于反射起着核心的作用。但它是一个抽象的基类，Type有与每种数据类型对应的派生类，我们使用这个派生类的对象的方法、字段、属性来查找有关该类型的所有信息。

获取给定类型的Type引用有3种常用方式：
●使用 C# typeof 运算符。
    Type t = typeof(string);
●使用对象GetType()方法。
    string s = "grayworm";
    Type t = s.GetType(); 
●还可以调用Type类的静态方法GetType()。
    Type t = Type.GetType("System.String");

Type 属性：

Name 数据类型名
FullName 数据类型的完全限定名(包括命名空间名)
 Namespace 定义数据类型的命名空间名
 IsAbstract 指示该类型是否是抽象类型
 IsArray   指示该类型是否是数组
 IsClass   指示该类型是否是类
 IsEnum   指示该类型是否是枚举
 IsInterface    指示该类型是否是接口
 IsPublic 指示该类型是否是公有的
 IsSealed 指示该类型是否是密封类
 IsValueType 指示该类型是否是值类型

Type类的方法：

    GetConstructor(), GetConstructors()：返回ConstructorInfo类型，用于取得该类的构造函数的信息
    GetEvent(), GetEvents()：返回EventInfo类型，用于取得该类的事件的信息
    GetField(), GetFields()：返回FieldInfo类型，用于取得该类的字段（成员变量）的信息
    GetInterface(), GetInterfaces()：返回InterfaceInfo类型，用于取得该类实现的接口的信息
    GetMember(), GetMembers()：返回MemberInfo类型，用于取得该类的所有成员的信息
    GetMethod(), GetMethods()：返回MethodInfo类型，用于取得该类的方法的信息
    GetProperty(), GetProperties()：返回PropertyInfo类型，用于取得该类的属性的信息
可以调用这些成员，其方式是调用Type的InvokeMember()方法，或者调用MethodInfo, PropertyInfo和其他类的Invoke()方法。

4.例子，便于理解

1. Demo(动态实例化对象)

using Systme.Reflection.Assembly

public static T CreateInstance<T>(string fullName,string assemblyName){
string path = fullName +","+assemblyName;//命名空间.类型名，程序集
Type o = Type.GetType(path)://加载类型
object obj = Activator.CreateInstance(o,true);//根据类型创建实例
return (T)obj;//类型转换并返回
}

public static T CreateInstance<T>(string assemblyName,string nameSpace,string className){
try 
{
string fullName = nameSpace+"."+className;
//第一种写法
object obj = Assembly.Load(assemblyName).CreateInstance(fullName);
return (T)obj;
}
}

2. 属性的使用

public class TestClass 
    {
//属性
        public string name { get; set; }
        public string mail { get; set; }
    }
class Program
    {
        static void Main(string[] args)
        {
            var t = typeof(TestClass);//返回Type
            var obj = Activator.CreateInstance(t);//用Activator生成对象 创建实例 object 类型
            //查看所有属性
            PropertyInfo[] piArray = t.GetProperties();
            foreach (PropertyInfo pi in piArray)
            {
                  Console.WriteLine(pi.Name);
            }
            var properName = t.GetProperty("name");//获取属性
            properName.SetValue(obj,"dd");//赋值
            var properMail = t.GetProperty("mail");
            properMail.SetValue(obj,"mail");
            var model = (TestClass) obj; //强制转换为实体
        }
    }

3. 字段和方法的使用

 public class TestClass
   {
       public int age;
       public string name;
       public string myProper { get; set; }
       //不带参数的公共方法
       public resMod NoParPrint()
       {
           return new resMod() { res = name + age + myProper };
       }
       //带参数的公共方法
       public string printMsg(string test)
       {
           return name + age;
       }
       //无参数静态方法
       public static string StaticNoParPrint()
       {
           return "无参数静态方法";
       }
       //带参数的静态方法
       public static string StaticParPrnt(string input)
       {
           return input + "1212";
       }
   }

   public class resMod
   {
       public string res { get; set; }
   }


class Program
   {
       static void Main(string[] args)
       {
           var t = typeof(TestClass);
           var obj = Activator.CreateInstance(t);
           var ageField = t.GetField("age");
           var nameField = t.GetField("name");
           var myProper = t.GetProperty("myProper");
           myProper.SetValue(obj,"Pro");
           ageField.SetValue(obj, 123);
           nameField.SetValue(obj, "w de name");


           var methodPrint = t.GetMethod("NoParPrint");
           //调用方法，res为返回值，此处为object类型，可转换为resMod,但有装箱拆箱操作
           //避免消耗，可使用list<>
           var res = methodPrint.Invoke(obj, null);

           object[] pars = new object[]{"test"};

           methodPrint = t.GetMethod("printMsg");
           res = methodPrint.Invoke(obj, pars);

           methodPrint = t.GetMethod("StaticNoParPrint");
           //静态方法 不需要实例对象
           res = methodPrint.Invoke(null, null);

           methodPrint = t.GetMethod("StaticParPrnt");
           res = methodPrint.Invoke(null, pars);
       }
   }

4. System.Reflection.Assembly类的用法
1、通过程序集名称返回Assembly对象

Assembly assembly = Assembly.Load("ReflectionDemo2");

2、通过DLL文件名称返回Assembly对象

Assembly assembly = Assembly.LoadFrom("ReflectionDemo2.dll");

3、通过Assembly获取程序集中类

Type t = assembly.GetType("ReflectionDemo2.ReflectionClass"); //参数必须是类的全名

4、通过Assembly获取程序集中所有的类
Type[] tArray = assembly.GetTypes();
5、通过程序集的名称反射

Assembly assembly = Assembly.Load("ReflectionDemo2");
Type t = assembly.GetType("ReflectionDemo2.ReflectionClass"); //参数必须是类的全名
object o = Activator.CreateInstance(t,"男");
MethodInfo mi = t.GetMethod("Show");
mi.Invoke(o,null);

6、通过DLL文件全名反射其中的所有类型

Assembly assembly = Assembly.LoadFrom("ReflectionDemo2.dll");
Type[] tArray = assembly.GetTypes();
foreach (Type t in tArray)
{
    if (t.FullName == "a.b.c")
    {
        object o = Activator.CreateInstance(t);
    }
}

###Done.