[C#] Assembly Management

入乡随俗的配图

之前在简介反射的时候提到过，我们可以在运行时加载dll并创建其中某种类型对应的实例。而本文呢，则打算讲讲如果把动态加载程序集和调用程序集中的方法规范化，集成到类中，从而便于使用和维护。

Assembly, is a reusable, versionable, and self-describing building block of a common language runtime application. 程序集，是.NET程序的最小组成单位，每个程序集都有自己的名称、版本等信息，程序集通常表现为一个或多个文件（.exe或.dll文件）。

1. 程序集的加载与管理

程序集的使用很多时候是通过反射获取程序集里面的类型或者方法，所以这里我们提供了一个AssemblyManager的类来管理加载的程序集，并提供获取类型实例GetInstance和特定方法GetMethod的函数。

简要介绍：
（1）loadedAssemblies成员
我们将已经加载过的Assembly保存在一个字典里，key为对应的程序集的path，这样下次使用它的时候就不必再重新Load一遍了，而是直接从字典中取出相关的Assembly。尽管据说AppDomain中的Assembly.Load是有优化的，即加载过的程序集会被保存在Global Assembly Cache (GAC)中，以后的Load会直接从cache里面取出。但这些都是对我们不可见的，我们自己建立一套缓存机制也无可厚非，至少我们可以更清晰地看到所有的处理逻辑。

（2）RegisterAssembly方法
这里我们提供了三种注册Assembly的方法，第一种，是直接提供程序集路径和程序集，我们直接把他们缓存到字典即可；第二种，是调用者还没有获取到相应的程序集，所以只提供了一个路径，我们会根据这个路径去加载相应的程序集，然后缓存在字典中；第三种，则提供了另外一种加载程序集的机制，如果调用者在程序内部只有程序集的完成内容（byte数组）而并没有对应的dll文件，则我们可以直接利用Assembly.Load()对其进行加载，不需要死板地写临时文件再从文件中加载程序集。

（3）GetMethod方法
用户指定程序集名、类名和方法名，我们根据这些参数返回该方法的MethodInfo。

（4）GetInstance方法
用户指定程序集名和类名，我们返回该类的一个实例。

using System;
using System.Reflection;
using System.Collections.Generic;

namespace AssemblyManagerExample
{
    public class AssemblyManager
    {
        private readonly Dictionary loadedAssemblies;

        public AssemblyManager()
        {
            this.loadedAssemblies = new Dictionary();
        }

        // Three different method to register assembly
        // 1: We already have the assembly
        // 2: Directly load assembly from path
        // 3: Load assembly from byte array, if we already have the dll content 
        public void RegisterAssembly(string assemblyPath, Assembly assembly)
        {
            if (!this.loadedAssemblies.ContainsKey(assemblyPath))
            {
                this.loadedAssemblies[assemblyPath] = assembly;
            }
        }

        public void RegisterAssembly(string assemblyPath)
        {
            if (!this.loadedAssemblies.ContainsKey(assemblyPath))
            {
                Assembly assembly = Assembly.LoadFrom(assemblyPath);
                if (assembly == null)
                {
                    throw new ArgumentException($"Unable to load assembly [{assemblyPath}]");
                }

                this.RegisterAssembly(assemblyPath, assembly);
            }
        }

        public void RegisterAssembly(string assemblyPath, byte[] assemblyContent)
        {
            if (!this.loadedAssemblies.ContainsKey(assemblyPath))
            {
                Assembly assembly = Assembly.Load(assemblyContent);
                if (assembly == null)
                {
                    throw new ArgumentException($"Unable to load assembly [{assemblyPath}]");
                }

                this.RegisterAssembly(assemblyPath, assembly);
            }
        }

        public Assembly GetAssembly(string assemblyPath)
        {
            this.RegisterAssembly(assemblyPath);

            return this.loadedAssemblies[assemblyPath];
        }

        public MethodInfo GetMethod(string assemblyPath, string typeName, string methodName)
        {
            Assembly assembly = this.GetAssembly(assemblyPath);

            Type type = assembly.GetType(typeName, false, true);
            if (type == null)
            {
                throw new ArgumentException($"Assembly [{assemblyPath}] does not contain type [{typeName}]");
            }

            MethodInfo methodInfo = type.GetMethod(methodName);
            if (methodInfo == null)
            {
                throw new ArgumentException($"Type [{typeName}] in assembly [{assemblyPath}] does not contain method [{methodName}]");
            }

            return methodInfo;
        }

        public object GetInstance(string assemblyPath, string typeName)
        {
            return this.GetAssembly(assemblyPath).CreateInstance(typeName);
        }              
    }
}

2. 执行动态加载的DLL中的方法

很多时候我们动态地加载DLL是为了执行其中的某个或者某些方法，这一点上节的Assembly Manager中并没有涉及。接下来这里将介绍两种调用的方式，并且通过实验测试一下重复调用这些方法时DLL会不会重复加载。
（1）利用Assembly.LoadFrom()方法从指定的文件路径加载Assembly，然后从得到的Assembly获取相应的类型type（注意这里的参数一定得是类型的FullName），再用Activator.CreateInstance()创建指定类型的一个对象，最后利用type的InvokeMember方法去调用该类型中的指定方法。

InvokeMember(String, BindingFlags, Binder, Object, Object[])
Invokes the specified member, using the specified binding constraints and matching the specified argument list.

public void RunFuncInUserdefinedDll(string dllName, string typeName, string funcName)
{
    Assembly assembly = Assembly.LoadFrom(dllName);
    if (assembly == null)
    {
        throw new FileNotFoundException(dllName);
    }

    Type type = assembly.GetType(typeName);
    if (type == null)
    {
        throw new ArgumentException($"Unable to get [{typeName}] from [{dllName}]");
    }
    object obj = Activator.CreateInstance(type);
    type.InvokeMember(funcName, BindingFlags.InvokeMethod, null, obj, null);
}

（2）其实最终还是一样调用Type.InvokeMember()方法去调用指定的方法，只是这里不再显示地去获取Assembly和Type，而是利用用户指定的assembly path和type name直接通过AppDomain来创建一个对象。（需要注意的是，使用该方法调用的方法一定要Serializable）

public void RunFuncInUserdefinedDll(string dllName, string typeName, string funcName)
{
    AppDomain domain = AppDomain.CreateDomain("NewDomain");
    object obj = domain.CreateInstanceFromAndUnwrap(dllName, typeName);
    obj.GetType().InvokeMember(funcName, BindingFlags.InvokeMethod, null, obj, null);
}

最后，我们来试试看调用上述方法两次时DLL的加载情况吧。为了确定是否受AppDomain的影响，我们让每次调用上述方法时创建的Domain的名字是一个随机的Guid字符串。我们在创建对象之前和之后分别打印我们新建的AppDomain里Assembly中的DLL名字。

public void RunFuncInUserdefinedDll(string dllName, string typeName, string funcName)
{
    AppDomain domain = AppDomain.CreateDomain(Guid.NewGuid().ToString());
    ListAssemblies(domain, "List Assemblies Before Creating Instance");

    object obj = domain.CreateInstanceFromAndUnwrap(dllName, typeName);
    ListAssemblies(domain, "List Assemblies After Creating Instance");

    obj.GetType().InvokeMember(funcName, BindingFlags.InvokeMethod, null, obj, null);
}

private void ListAssemblies(AppDomain domain, string message)
{
    Console.WriteLine($"*** {message}");
    foreach (Assembly assembly in domain.GetAssemblies())
    {
        Console.WriteLine(assembly.FullName);
    }
    Console.WriteLine("***");
}

为了更加有效地捕捉道DLL具体是在什么时机被加载进来，我们在Main方法的入口给AppDomain.CurrentDomain.AssemblyLoad绑定一个事件。有了这个事件，只要有Assembly加载发生，就会打印当时正在加载的Assembly的FullName。

AppDomain.CurrentDomain.AssemblyLoad += (e, arg) =>
{
    Console.WriteLine($"AssemblyLoad Called by: {arg.LoadedAssembly.FullName}");
};

下面是调用两次时输出的信息：

>AssemblyManagement.exe ClassLibrary1.dll ClassLibrary1.Class1 Method1

*** List Assemblies Before Creating Instance
mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
***
AssemblyLoad Called by: ClassLibrary1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
*** List Assemblies After Creating Instance
mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
ClassLibrary1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
***
This is Method1 in Class1
*** List Assemblies Before Creating Instance
mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
***
*** List Assemblies After Creating Instance
mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
ClassLibrary1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
***
This is Method1 in Class1

从上述结果我们可以看到，两次调用的时候在创建对象之前AppDomain中都是只有一个系统Assembly mscorlib，而创建对象之后则新增了我们自定义的ClassLibrary1。
但不同的是在第一个调用中创建对象的时候，我们看到了AssemblyLoad Called的输出信息，即我们自定义的DLL是在那个时机被加载进来的。而第二次调用该函数的时候虽然那个AppDomain中也没有那个Assembly，但是somehow它被缓存在某个地方所以不需要重新加载。

最后，写完第2节时，我有那么一瞬间觉得第一节并不需要，因为加载Assembly本身就已经有缓存机制了。但是再细想一下，我们自定义的Assembly Manager至少还有两个优点：1）使用更加灵活。如果我们两在两个不同的方法中分别使用同一个DLL的两个不同版本，直接使用Assembly.LoadFrom很难做到，即使你试图把这两个DLL分隔在不同的AppDomain里面。如果我们自己直接从byte[]中加载DLL，则完全可以在loadedAssemblies中利用不同的key来区分相同DLL的不同版本。2）可以把Assembly Manager作为类的成员，这样就可以把assembly区分到类型的粒度而不是AppDomain。

[C#] Assembly Management

1. 程序集的加载与管理

2. 执行动态加载的DLL中的方法

你可能感兴趣的:([C#] Assembly Management)