C#反射机制

概述

反射是.NET中的重要机制，通过反射，可以在运行时获得程序或程序集中每一个类型（包括类、结构、委托、接口和枚举等）的成员和成员的信息。有了反射，即可对每一个类型了如指掌。另外我还可以直接创建对象，即使这个对象的类型在编译时还不知道。

作用

1.可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型；
2.应用程序需要在运行时从某个特定的程序集中载入一个特定的类型，以便实现某个任务时可以使用到反射；
3.反射主要应用与类库，这些类需要知道一个类型的定义，以便提供更多的功能
反射可以获得程序或程序集的信息，也可以动态的加载程序集，并创建其中某个类型的实例，执行实例中的方法。

方法

（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了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。

命名空间

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

System.Type类

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

1. 获取给定类型的Type引用有3种常用方式：

●使用 C# typeof 运算符。
    Type t = typeof(string);
●使用对象GetType()方法。
    string s = "grayworm";
    Type t = s.GetType(); 
●还可以调用Type类的静态方法GetType()。
    Type t = Type.GetType("System.String");*

2. Type类的属性

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

3. Type类的方法

    GetConstructor(), GetConstructors()：返回ConstructorInfo类型，用于取得该类的构造函数的信息
    GetEvent(), GetEvents()：返回EventInfo类型，用于取得该类的事件的信息
    GetField(), GetFields()：返回FieldInfo类型，用于取得该类的字段（成员变量）的信息
    GetInterface(), GetInterfaces()：返回InterfaceInfo类型，用于取得该类实现的接口的信息
    GetMember(), GetMembers()：返回MemberInfo类型，用于取得该类的所有成员的信息
    GetMethod(), GetMethods()：返回MethodInfo类型，用于取得该类的方法的信息
    GetProperty(), GetProperties()：返回PropertyInfo类型，用于取得该类的属性的信息

4. 反射在System.Type类的应用

using System;
using System.Reflection;
 
 
namespace TestCsharp
{
    class Contact
    {
        // Read-only properties.  
        public string Name { get; private set; }
        public string Address { get; private set; }
 
        public string m_sMail;
 
        // Public constructor.  
        public Contact()
        {
 
        }
        public Contact(string contactName, string contactAddress)
        {
            Name = contactName;
            Address = contactAddress;
        }
        public void Print()
        {
            Console.WriteLine("Name:" + Name + " Address:" + Address);
        }
    }  
    class Program
    {
        static void Main(string[] args)
        {
            Contact pt = new Contact();
            Type t = pt.GetType();
           
            ConstructorInfo[] ci = t.GetConstructors();    //获取类的所有构造函数
            Console.WriteLine("1.查看类中的构造方法:");
            Console.WriteLine("构造函数一个有"+ci.Length+"个");
            int num = 0;
            foreach (ConstructorInfo c in ci) //遍历每一个构造函数
            {
                ParameterInfo[] ps = c.GetParameters();    //取出每个构造函数的所有参数
                foreach (ParameterInfo pi in ps)   //遍历并打印所该构造函数的所有参数
                {
                    Console.Write(pi.ParameterType.ToString() + " " + pi.Name + ",");
                }
                Console.WriteLine("这是第" + num++ + "个");
            }
           
            Console.WriteLine("\n2.查看类中的属性:");
            PropertyInfo[] pis = t.GetProperties();
            foreach (PropertyInfo pi in pis)
            {
                Console.WriteLine(pi.Name);
            }
 
            Console.WriteLine("\n3.查看类中的public方法:");
            MethodInfo[] mis = t.GetMethods();
            foreach (MethodInfo mi in mis)
            {
                Console.WriteLine(mi.ReturnType + " " + mi.Name);
            }
 
            Console.WriteLine("\n4.查看类中的pulic字段:");
            FieldInfo[] fis = t.GetFields();
            foreach (FieldInfo fi in fis)
            {
                Console.WriteLine(fi.Name);
            }
 
 
            Console.WriteLine("\n5.用构造函数动态生成对象：");
            Type[] tt = new Type[2];
            tt[0] = typeof(string);
            tt[1] = typeof(string);
            //根据参数类型获取构造函数 
            ConstructorInfo ctInfo = t.GetConstructor(tt); 
            //构造Object数组，作为构造函数的输入参数 
            object[] obj = new object[2]{"张三","上海浦东"};   
            //调用构造函数生成对象 
            object o = ctInfo.Invoke(obj);    
            //调用生成的对象的方法测试是否对象生成成功 
            ((Contact)o).Print();
 
            Console.WriteLine("\n6.用Activator生成对象：");//
            //构造函数的参数 
            object[] objs = new object[2] { "李四", "北京王府井" };   
            //用Activator的CreateInstance静态方法，生成新对象 
            object ob = Activator.CreateInstance(t, objs);
            ((Contact)ob).Print();
 
            Console.WriteLine("\n7.用反射生成对象，并调用属性、方法和字段进行操作：");  
            object obNew = Activator.CreateInstance(t);
            //取得m_sMail字段 
            FieldInfo fi6 = t.GetField("m_sMail");
            //给m_sMail字段赋值 
            fi6.SetValue(obNew, "hawkitachi@gmail.com");
            //取得Name属性 
            PropertyInfo pi6 = t.GetProperty("Name");
            //给MyName属性赋值 
            pi6.SetValue(obNew, "王二麻", null);
            PropertyInfo pInfo6 = t.GetProperty("Address");
            pInfo6.SetValue(obNew, "江苏南京", null);
            //取得show方法 
            MethodInfo mi6 = t.GetMethod("Print");
            //调用show方法 
            mi6.Invoke(obNew, null);
            Console.Read();
        }
    }
}

输出结果

调用

namespace ReflectionTest
{
    class ReflectionHelper
    {
        public void InvokeMethod()
        {
            #region 方法一
            Assembly assembly1 = Assembly.Load("ReflectionTest");
            Type type1 = assembly1.GetType("ReflectionTest.Person");
            object obj1 = System.Activator.CreateInstance(type1);
            MethodInfo method1 = type1.GetMethod("Show");
            method1.Invoke(obj1, null);
            #endregion

            #region 方法二
            object obj2 = Assembly.Load("ReflectionTest").CreateInstance("ReflectionTest.Person");
            Type type2 = obj2.GetType();
            MethodInfo method = type2.GetMethod("Show");
            method.Invoke(obj2, null);
            #endregion
        }
    }
}