动态的加载类型

开篇先熟悉两个小概念：

早绑定：是指在编译时绑定对象的类型

晚绑定：是指在运行时才绑定对象的类型。

当然我们提到上面两个概念，肯定是为了引入今天的主题——利用反射实现晚绑定（也就是动态的加载类型，并调用它们）。

我暂时只是为了测试的方便先定义一个不能执行的程序集（Person.dll）无需写的完善，仅仅作为测试使用，之后我们在这个程序中调用它。

person.dll内部如下：

 using System;
    public class Chinese
    {
        private string language;
        private string name;
        private int age;
        private string like;
        public string Like
        {
            get { return like; }
            set { like = value; }
        } 
        public string Language
        {
            get { return language; }
            set { language = value; }
        }
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        public virtual void Favourite()
        {
            Console.WriteLine(name+"今年"+age+岁"喜欢的运动是:"+this.like);
        }
        public Chinese()
        { 
        }
        public Chiese(string name, int age)
        {
            this.name = name;
            this.age = age;
        }
    }

注意：当我们不用vs生成注意程序集的时候，一定要注意主程序运行时不能低于该程序集的运行时，默认的使用命令提示执行时使用的是最新的运行时：例如：我这里执行了：

之后执行主程序报错，于是更新了一下运行时版本就OK了。

如果我们这样定义：就会发生早绑定，因为编译时，编译器将从程序集中导入Chinese类。

Chiesep1=new Chiese("小强",18);

那么我们怎么实现晚绑定呢？

现在我们再看下开篇晚绑定的概念，也就是说我们这里实现的效果是：不会再元数据中嵌入对类型的引用，而是在运行是通过反射来实现。现在我们就开始动态加载类型和调用方法。先看一种方式：

1. 使用Assembly类的Load方法来动态的来动态的加载指定的程序集。
2. 使用Assembly类的GetType方法来动态的加载指定的类型。
3. 通过Type类的InvokeMember方法来调用Type对象所表示的类型方法。

下面的代码演示如歌动态的加载程序集Person.dll，动态的加载Chinese类型，并调用Favourite方法：

using System;
using System.IO;
using System.Reflection;

namespace 动态的加载类型
{
    class Program
    {
        static void Main()
        {
            //加载程序集
            string assemblyPath = Path.Combine(Environment.CurrentDirectory, "person.dll");
            Assembly a = Assembly.LoadFrom(assemblyPath);
           //获取指定的类型
            Type t = a.GetType("Chinese");
           //构造类型实例
            Object[] args = new Object[] { "小强",18 };
            Object obj = t.InvokeMember(null,
                BindingFlags.DeclaredOnly |                       //指定绑定类型
                BindingFlags.Public | BindingFlags.NonPublic |
                BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);
            Console.WriteLine("新创建的类型: " + obj.GetType().ToString());
            Console.WriteLine("================");
            //给字段like赋值
            t.InvokeMember("like",
           BindingFlags.DeclaredOnly |
           BindingFlags.Public | BindingFlags.NonPublic |
           BindingFlags.Instance | BindingFlags.SetField, null, obj, new Object[] { "抓篮球" });
            //调用方法
            t.InvokeMember("Favourite", BindingFlags.DeclaredOnly |
            BindingFlags.Public | BindingFlags.NonPublic |
            BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, null);
            Console.ReadKey();
        }
    }
}

利用System.Activator类

　　　　承接上面的实例更简单的加载类型的方法，就是利用System.Activator类。

该类包含特定的方法，用以在本地或从远程创建对象类型，或获取对现有远程对象的引用。此类不能被继承。

步骤如下： 

1.加载程序集并调用GetType方法获取目标类型对象

2.调用Activator.CreateInstance(Type)使用指定类型的默认构造函数来创建该类型的实例,并通过Type对象的GetMethod方法来获取MethodInfo对象

3.使用MethodInfo对象的Invoke方法来动态的执行方法。

using System;
using System.Reflection;

namespace Test
{
    class Program
    {
        static void Main()
        {
            Assembly a = Assembly.Load("person.dll");
            Type t = a.GetType("Chinese");
            Object[] args = new Object[] { "小强", 18 };
            object obj = Activator.CreateInstance(t, args);
            MethodInfo mi = t.GetMethod("Favourite");
            mi.Invoke(obj, null);
            Console.ReadKey();
        }
    }
}

执行效果图：