如何使用所有引用递归地将程序集加载到 AppDomain？

您需要处理 AppDomain。程序集解析或应用程序域。如果引用的程序集不在 GAC 或 CLR 的探测路径中，则反射 OnlyAssemblyResolve 事件(取决于您正在进行的加载)。

组装解决方案

只反射程序集解决方案

在新的 AppDomain 上，尝试设置一个 AssemblyResolve事件处理程序。当依赖项丢失时将调用该事件。

Http://support.microsoft.com/kb/837908/en-us

C # 版本:

Create a moderator class and inherit it from MarshalByRefObject:

class ProxyDomain : MarshalByRefObject
{
public Assembly GetAssembly(string assemblyPath)
{
try
{
return Assembly.LoadFrom(assemblyPath);
}
catch (Exception ex)
{
throw new InvalidOperationException(ex.Message);
}
}
}

call from client site

ProxyDomain pd = new ProxyDomain();
Assembly assembly = pd.GetAssembly(assemblyFilePath);

在外部应用程序域中执行代理对象之前，需要调用 CreateInstanceAndUnwrap。

 class Program
{
static void Main(string[] args)
{
AppDomainSetup domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = System.Environment.CurrentDirectory;
Evidence adevidence = AppDomain.CurrentDomain.Evidence;
AppDomain domain = AppDomain.CreateDomain("MyDomain", adevidence, domaininfo);


Type type = typeof(Proxy);
var value = (Proxy)domain.CreateInstanceAndUnwrap(
type.Assembly.FullName,
type.FullName);


var assembly = value.GetAssembly(args[0]);
// AppDomain.Unload(domain);
}
}


public class Proxy : MarshalByRefObject
{
public Assembly GetAssembly(string assemblyPath)
{
try
{
return Assembly.LoadFile(assemblyPath);
}
catch (Exception)
{
return null;
// throw new InvalidOperationException(ex);
}
}
}

另外，请注意，如果您使用 LoadFrom，您可能会得到一个 FileNotFound异常，因为 Assembly 解析器将尝试在 GAC 或当前应用程序的 bin 文件夹中找到您正在加载的程序集。使用 LoadFile加载任意的汇编文件——但是请注意，如果这样做，您将需要自己加载任何依赖项。

密钥是 AppDomain 引发的 AssemblyResolve 事件。

[STAThread]
static void Main(string[] args)
{
fileDialog.ShowDialog();
string fileName = fileDialog.FileName;
if (string.IsNullOrEmpty(fileName) == false)
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
if (Directory.Exists(@"c:\Provisioning\") == false)
Directory.CreateDirectory(@"c:\Provisioning\");


assemblyDirectory = Path.GetDirectoryName(fileName);
Assembly loadedAssembly = Assembly.LoadFile(fileName);


List<Type> assemblyTypes = loadedAssembly.GetTypes().ToList<Type>();


foreach (var type in assemblyTypes)
{
if (type.IsInterface == false)
{
StreamWriter jsonFile = File.CreateText(string.Format(@"c:\Provisioning\{0}.json", type.Name));
JavaScriptSerializer serializer = new JavaScriptSerializer();
jsonFile.WriteLine(serializer.Serialize(Activator.CreateInstance(type)));
jsonFile.Close();
}
}
}
}


static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
string[] tokens = args.Name.Split(",".ToCharArray());
System.Diagnostics.Debug.WriteLine("Resolving : " + args.Name);
return Assembly.LoadFile(Path.Combine(new string[]{assemblyDirectory,tokens[0]+ ".dll"}));
}

将程序集实例传递回调用方域后，调用方域将尝试加载它！这就是为什么你得到了例外。这在您的最后一行代码中发生:

domain.Load(AssemblyName.GetAssemblyName(path));

Thus, whatever you want to do with the assembly, should be done in a proxy class - a class which inherit MarshalByRefObject.

考虑到调用方域和新创建的域都应该可以访问代理类程序集。如果您的问题并不太复杂，可以考虑让 ApplicationBase 文件夹保持不变，这样它将与调用方域文件夹相同(新域将只加载它所需的 Assembly)。

在简单的代码中:

public void DoStuffInOtherDomain()
{
const string assemblyPath = @"[AsmPath]";
var newDomain = AppDomain.CreateDomain("newDomain");
var asmLoaderProxy = (ProxyDomain)newDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(ProxyDomain).FullName);


asmLoaderProxy.GetAssembly(assemblyPath);
}


class ProxyDomain : MarshalByRefObject
{
public void GetAssembly(string AssemblyPath)
{
try
{
Assembly.LoadFrom(AssemblyPath);
//If you want to do anything further to that assembly, you need to do it here.
}
catch (Exception ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
}
}

如果您确实需要从与当前应用程序域文件夹不同的文件夹中加载程序集，请创建具有特定 dlls 搜索路径文件夹的新应用程序域。

例如，上面代码中的应用程序域创建行应该替换为:

var dllsSearchPath = @"[dlls search path for new app domain]";
AppDomain newDomain = AppDomain.CreateDomain("newDomain", new Evidence(), dllsSearchPath, "", true);

这样，所有 dll 都将自动从 dllsSearchPath 解析。

我花了一段时间才理解@user1996230的回答，所以我决定提供一个更明确的例子。在下面的示例中，我为装载在另一个 AppDomain 中的对象创建一个代理，并从另一个域调用该对象的方法。

class ProxyObject : MarshalByRefObject
{
private Type _type;
private Object _object;


public void InstantiateObject(string AssemblyPath, string typeName, object[] args)
{
assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + AssemblyPath); //LoadFrom loads dependent DLLs (assuming they are in the app domain's base directory
_type = assembly.GetType(typeName);
_object = Activator.CreateInstance(_type, args); ;
}


public void InvokeMethod(string methodName, object[] args)
{
var methodinfo = _type.GetMethod(methodName);
methodinfo.Invoke(_object, args);
}
}


static void Main(string[] args)
{
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationBase = @"SomePathWithDLLs";
AppDomain domain = AppDomain.CreateDomain("MyDomain", null, setup);
ProxyObject proxyObject = (ProxyObject)domain.CreateInstanceFromAndUnwrap(typeof(ProxyObject).Assembly.Location,"ProxyObject");
proxyObject.InstantiateObject("SomeDLL","SomeType", new object[] { "someArgs});
proxyObject.InvokeMethod("foo",new object[] { "bar"});
}

我不得不这样做了好几次，并研究了许多不同的解决方案。

我发现最优雅和最容易实现的解决方案可以这样实现。

1. 创建一个可以创建简单界面的项目

接口将包含您希望调用的任何成员的签名

public interface IExampleProxy
{
string HelloWorld( string name );
}

public interface Example : MarshalByRefObject, IExampleProxy
{
public string HelloWorld( string name )
{
return $"Hello '{ name }'";
}
}

// set up domain and create
AppDomainSetup domaininfo = new AppDomainSetup
{
ApplicationBase = System.Environment.CurrentDirectory
};


Evidence adevidence = AppDomain.CurrentDomain.Evidence;


AppDomain exampleDomain = AppDomain.CreateDomain("Example", adevidence, domaininfo);


// assembly ant data names
var assemblyName = "<AssemblyName>, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null|<keyIfSigned>";
var exampleTypeName = "Example";


// Optional - get a reflection only assembly type reference
var @type = Assembly.ReflectionOnlyLoad( assemblyName ).GetType( exampleTypeName );


// create a instance of the `Example` and assign to proxy type variable
IExampleProxy proxy= ( IExampleProxy )exampleDomain.CreateInstanceAndUnwrap( assemblyName, exampleTypeName );


// Optional - if you got a type ref
IExampleProxy proxy= ( IExampleProxy )exampleDomain.CreateInstanceAndUnwrap( @type.Assembly.Name, @type.Name );


// call any members you wish
var stringFromOtherAd = proxy.HelloWorld( "Tommy" );


// unload the `AppDomain`
AppDomain.Unload( exampleDomain );