C#反射-Assembly.Load、LoadFrom与LoadFile

反射Demo：

public class Person
{
    public int Age;

    public void SayHello()
    {
        Console.WriteLine("Hello Person");
    }
}

class Program
{
    static void Main(string[] args)
    {
        //把程序集像读取文件一样读取出来，动态的调用程序集里面的方法
        Person p = new Person();
        /*
         * 使用Type描述类型特征
            Type t1=typeof(ClassName);
            Type t2=ClassName.GetType();

            t1.GetEvents/t1.GetFields/
            t1.GetMembers
            t1.GetMethods() //返回所有公共方法
         */
        Type t1 = typeof(Person);
        Type t2 = p.GetType();

        //GetEvents 获取所有的事件
        EventInfo[] events = t1.GetEvents();
        foreach (var item in events)
        {
            Console.WriteLine("Event: " + item.Name);
        }
        //GetFields 获取所有的public字段
        FieldInfo[] fields = t1.GetFields();
        foreach (var item in fields)
        {
            Console.WriteLine("Fields: " + item.Name);
        }
        //GetMethods 获取所有的方法
        MethodInfo[] methods = t1.GetMethods();
        foreach (var item in methods)
        {
            Console.WriteLine("Method: " + item.Name);
        }
        Console.ReadKey();
    }
}

反射：【从文件中读取程序集中的成员，并使用它】

->实现步骤：

->使用Assembly.LoadFrom(文件名全名)  【获得程序集对象Assembly】

->使用GetTypes()获得所有的类型信息(Type对象) 【读取类型 GetType】

->Activator.CreateInstance(Type类型的数据)创建指定类型的对象  【创建对象 Activator.CreateInstance】//实例.方法()

->如果需要调用方法，使用<type>.GetMethod(方法名)获得MethodInfo类型对象 【获得方法 <type>.GetMethod】

->调用 方法对象.Innvoke(实例，参数);

//DrHao 类库

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DrHao
{
    public class Hao
    {
        public void Fun1()
        {
            Console.WriteLine("我是没有参数的Fun1");
        }

        public void Fun1(int num1)
        {
            Console.WriteLine("参数是：" + num1);
        }

        public int Fun1(int num1, int num2)
        {
            return num1 + num2;
        }

        private void Func()
        {
            Console.WriteLine("无参数的私有方法");
        }
    }
}

//Main函数

class Program
{
    static void Main(string[] args)
    {
        //把程序集像读取文件一样读取出来，动态的调用程序集里面的方法

        //反射
        //读取程序集
        Assembly asm = Assembly.LoadFrom(@"E:\Program2013\20160416_Reflect\DrHao\bin\Debug\DrHao.dll");
        //读取类型
        Type t = asm.GetType("DrHao.Hao");
        //创建对象信息
        object o = Activator.CreateInstance(t);
        //获得方法
        ////私有方法
        //MethodInfo method = t.GetMethod("Func", BindingFlags.Instance|BindingFlags.NonPublic);

        MethodInfo method = t.GetMethod("Fun1", new Type[] { typeof(int), typeof(int) });

        object result = method.Invoke(o, new object[] { ,  });
        Console.WriteLine("|{0}|", result);
        Console.ReadKey();
    }
}

关于.NET中的反射，常用的有三个方法：

Assembly.Load()

Assembly.LoadFrom()

Assembly.LoadFile()

1. Assembly.Load() 

Load()方法接收一个String或AssemblyName类型作为参数，这个参数实际上是需要加载的程序集的强名称（名称，版本，语言，公钥标记）。

例如.NET 2.0中的FileIOPermission类，它的强名称是：

System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

对于弱命名的程序集，则只会有程序集名称，而不会有版本，语言和公钥标记。如 TestClassLibrary

2. Assembly.LoadFrom()

LoadFrom()方法可以从指定文件中加载程序集，通过查找程序集的AssemblyRef元数据表，得知所有引用和需要的程序集，然后在内部调用Load()方法进行加载。

Assembly.LoadFrom(@"C:\ABC\Test.dll");

3. Assembly.LoadFile()

LoadFile()从一个指定文件中加载程序集，它和LoadFrom()的不同之处在于LoadFile()不会加载目标程序集所引用和依赖的其他程序集。

您需要自己控制并显示加载所有依赖的程序集

Assembly.Load()方法，Assembly.LoadFrom()方法，Assembly.LoadFile()方法的区别！

1：Assembly.Load()

这个方法通过程序集的长名称（包括程序集名，版本信息，语言文化，公钥标记）来加载程序集的，会加载此程序集引用的其他程序集，

一般情况下都应该优先使用 这个方法，他的执行效率比LoadFrom要高很多，而且不会造成重复加载的问题（原因在第2点上说明）

使用这个方法的时候， CLR会应用一定的策略来查找程序集，实际上CLR按如下的顺序来定位程序集：

⑴如果程序集有强名称，在首先在全局程序集缓(GAC)中查找程序集。

⑵如果程序集的强名称没有正确指定或GAC中找不到，那么通过配置文件中的<codebase>元素指定的URL来查找

⑶如果没有指定强名称或是在GAC中找不到，CLR会探测特定的文件夹：

假设你的应用程序目录是C:\AppDir,<probing>元素中的privatePath指定了一个路径Path1,你要定位的程序集是AssemblyName.dll则CLR将按照如下顺序定位程序集

　　C:\AppDir\AssemblyName.dll

　　C:\AppDir\AssemblyName\AssemblyName.dll

　　C:\AppDir\Path1\AssemblyName.dll

　　C:\AppDir\Path1\AssemblyName\AssemblyName.dll

如果以上方法不能找到程序集，会发生编译错误，如果是动态加载程序集，会在运行时抛出异常！

2：Assembly.LoadFrom()

这个方法从指定的路径来加载程序集，实际上这个方法被调用的时候，CLR会打开这个文件，获取其中的程序集版本，语言文化，公钥标记等信息，把他们传递给 Load方法，

接着，Load方法采用上面的策略来查找程序集。如果找到了程序集，会和LoadFrom方法中指定的路径做比较，如果路径相同，该程序集会被认为是应用程序的一部分，

如果路径不同或Load方法没有找到程序集，那该程序集只是被作为一个“数据文件”来加载，不会被认为是应用程序的一部分。

这就是在第1点中提到的Load方法比LoadFrom方法的执行效率高的原因。

另外，由于可能把程序集作为“数据文件”来加载，所以使用 LoadFrom从不同路径加载相同程序集的时候会导致重复加载。当然这个方法会加载此程序集引用的其他程序集。

3：Assembly.LoadFile()

这个方法是从指定的文件来加载程序集，和上面方法的不同之处是这个方法不会加载此程序集引用的其他程序集！

结论：一般大家应该优先选择Load方法来加载程序集，如果遇到需要使用LoadFrom方法的时候，最好改变设计而用Load方法来代替！

另：Assembly.LoadFile 与 Assembly.LoadFrom的区别

1、Assembly.LoadFile只载入相应的dll文件，比如Assembly.LoadFile("abc.dll")，则载入abc.dll，假如abc.dll中引用了def.dll的话，def.dll并不会被载入。

Assembly.LoadFrom则不一样，它会载入dll文件及其引用的其他dll，比如上面的例子，def.dll也会被载入。

2、用Assembly.LoadFrom载入一个Assembly时，会先检查前面是否已经载入过相同名字的Assembly，比如abc.dll有两个版本(版本1在目录1下，版本2放在目录2下)，

程序一开始时载入了版本1，当使用Assembly.LoadFrom("2\\abc.dll")载入版本2时，不能载入，而是返回版本1。

Assembly.LoadFile的话则不会做这样的检查，比如上面的例子换成Assembly.LoadFile的话，则能正确载入版本2。

LoadFile:加载指定路径上的程序集文件的内容。LoadFrom: 根据程序集的文件名加载程序集文件的内容。

区别：

LoadFile 方法用来来加载和检查具有相同标识但位于不同路径中的程序集.但不会加载程序的依赖项。

LoadFrom 不能用于加载标识相同但路径不同的程序集。

参考资料：http://www.cnblogs.com/zagelover/articles/2726034.html