Cómo cargar un ensamblado en AppDomain con todas las referencias recursivamente?

Question

Quiero cargar a un nuevo AppDomain algún ensamblado que tenga un árbol de referencias complejas (MyDll.dll -> Microsoft.Office.Interop.Excel.dll -> Microsoft.Vbe.Interop.dll -> Office.dll -> stdole .dll)

Según tengo entendido, cuando se carga un ensamblaje en AppDomain, sus referencias no se cargan automáticamente, y tengo que cargarlas manualmente. Así que cuando lo haga:

string dir = @"SomePath"; // different from AppDomain.CurrentDomain.BaseDirectory 
string path = System.IO.Path.Combine(dir, "MyDll.dll"); 

AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation; 
setup.ApplicationBase = dir; 
AppDomain domain = AppDomain.CreateDomain("SomeAppDomain", null, setup); 

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

y me FileNotFoundException:

No se pudo cargar el archivo o ensamblado 'MyDll, versión = 1.0.0.0, Culture = neutral, PublicKeyToken = null' o uno de sus dependencias. El sistema no puede encontrar el archivo especificado.

Creo que la parte clave es una de sus dependencias.

Ok, es el siguiente paso antes de domain.Load(AssemblyName.GetAssemblyName(path));

foreach (AssemblyName refAsmName in Assembly.ReflectionOnlyLoadFrom(path).GetReferencedAssemblies()) 
{ 
    domain.Load(refAsmName); 
} 

Pero tiene FileNotFoundException de nuevo, en otro montaje (referencia).

¿Cómo cargar todas las referencias recursivamente?

¿Tengo que crear el árbol de referencias antes de cargar el ensamblaje raíz? ¿Cómo obtener las referencias de un ensamblaje sin cargarlo?

Answer 1

Es necesario invocar CreateInstanceAndUnwrap antes su obj proxy ect se ejecutará en el dominio de la aplicación extranjera.

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); 
     } 
    } 
} 

Además, tenga en cuenta que si utiliza LoadFrom probablemente obtendrá una excepción FileNotFound debido a que la resolución de la Asamblea intentará encontrar el conjunto va a cargar en la GAC ​​o carpeta bin de la aplicación actual.Use LoadFile para cargar un archivo de ensamblaje arbitrario en su lugar, pero tenga en cuenta que si hace esto, tendrá que cargar las dependencias usted mismo.

Answer 2

Debe controlar los eventos AppDomain.AssemblyResolve o AppDomain.ReflectionOnlyAssemblyResolve (dependiendo de la carga que esté realizando) en caso de que el ensamblaje al que se hace referencia no se encuentre en el GAC o en la ruta de exploración del CLR.

AppDomain.AssemblyResolve

AppDomain.ReflectionOnlyAssemblyResolve

Answer 3

En su nuevo dominio de aplicación, intente configurar un controlador AssemblyResolve evento. Se llama a ese evento cuando falta una dependencia.

Answer 4

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

C# versión:

crear una clase moderador y heredan de MarshalByRefObject:

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

llamada del sitio del cliente

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

Answer 5

La clave es el evento AssemblyResolve generado por el dominio de la aplicación.

[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"})); 
} 

Answer 6

Una vez que pase la instancia de ensamblaje de vuelta al dominio de la persona que llama, el dominio llamante intentará cargarlo. Es por eso que obtienes la excepción. Esto sucede en su última línea de código:

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

Por lo tanto, lo que usted quiere hacer con el montaje, se debe hacer en una clase de proxy - una clase que hereda MarshalByRefObject.

Tenga en cuenta que tanto el dominio llamante como el nuevo dominio creado deben tener acceso al conjunto de la clase proxy. Si su problema no es demasiado complicado, considere dejar la carpeta ApplicationBase sin cambios, por lo que será igual a la carpeta del dominio llamante (el nuevo dominio solo cargará los ensambles que necesite).

En código simple:

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); 
     } 
    } 
} 

Si necesita cargar los ensamblados de una carpeta que es diferente de lo que carpeta de dominio aplicación actual, crear el nuevo dominio de aplicación con la carpeta de archivos DLL específicos ruta de búsqueda.

Por ejemplo, la línea de creación de dominios aplicación desde el código anterior debe ser reemplazado con:

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

De esta manera, todas las DLL automaically se resolverán de dllsSearchPath.

Answer 7

Me tomó un tiempo entender la respuesta de @ user1996230, así que decidí dar un ejemplo más explícito. En el ejemplo siguiente, hago un proxy para un objeto cargado en otro AppDomain y llamo a un método en ese objeto desde otro dominio.

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"}); 
}