Come caricare un assieme su AppDomain con tutti i riferimenti in modo ricorsivo?

Question

Voglio caricare su un nuovo AppDomain un assembly che ha un albero di riferimenti complessi (MyDll.dll -> Microsoft.Office.Interop.Excel.dll -> Microsoft.Vbe.Interop.dll -> Office.dll -> stdole .dll)

Per quanto ho capito, quando un assembly viene caricato su AppDomain, i suoi riferimenti non verrebbero caricati automaticamente e devo caricarli manualmente. Così, quando lo faccio:

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

e ottenuto FileNotFoundException:

Impossibile caricare il file o l'assembly 'MyDll, Version = 1.0.0.0, Culture = neutral, PublicKeyToken = null' o uno dei suoi dipendenze. Il sistema non trova il file specificato.

Penso che la parte chiave sia una delle sue dipendenze.

Ok, devo fare prima domain.Load(AssemblyName.GetAssemblyName(path));

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

Ma got FileNotFoundException ancora una volta, su un altro di montaggio (riferimento).

Come caricare tutti i riferimenti in modo ricorsivo?

Devo creare un albero dei riferimenti prima di caricare l'assemblaggio della radice? Come ottenere i riferimenti di un assembly senza caricarlo?

Answer 1

È necessario richiamare CreateInstanceAndUnwrap prima il tuo proxy obj ect verrà eseguito nel dominio dell'applicazione esterna.

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

Inoltre, notare che se si utilizza LoadFrom è probabile ottenere un'eccezione FileNotFound perché il risolutore Assemblea tenterà di trovare il gruppo che si desidera caricare nel GAC o cartella bin dell'applicazione corrente.Utilizzare LoadFile per caricare invece un file di assembly arbitrario, ma si noti che se si esegue questa operazione è necessario caricare autonomamente qualsiasi dipendenza.

Answer 2

È necessario gestire gli eventi AppDomain.AssemblyResolve o AppDomain.ReflectionOnlyAssemblyResolve (a seconda del carico che si sta eseguendo) nel caso in cui l'assembly di riferimento non si trovi nel GAC o nel percorso di verifica del CLR.

AppDomain.AssemblyResolve

AppDomain.ReflectionOnlyAssemblyResolve

Answer 3

Sul nuovo AppDomain, provare a impostare un gestore di eventi AssemblyResolve. Questo evento viene chiamato quando manca una dipendenza.

Answer 4

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

C# versione:

Creare una classe moderatore e ereditano da MarshalByRefObject:

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

chiamata dal sito client

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

Answer 5

La chiave è l'evento AssemblyResolve generato dall'AppDomain.

[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 volta superato l'istanza di assemblaggio di nuovo al dominio del chiamante, il dominio del chiamante cercherà di caricarlo! Questo è il motivo per cui ottieni l'eccezione. Questo accade nella vostra ultima riga di codice:

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

Quindi, qualsiasi cosa si vuole fare con il montaggio, dovrebbe essere fatto in una classe proxy - una classe che erediti MarshalByRefObject.

Considerare che il dominio del chiamante e il nuovo dominio creato devono entrambi avere accesso all'assembly della classe del proxy. Se il problema non è troppo complicato, si consiglia di lasciare invariata la cartella ApplicationBase, quindi sarà uguale alla cartella del dominio chiamante (il nuovo dominio caricherà solo gli assembly necessari).

Nel codice semplice:

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

Se si ha bisogno di caricare le assemblee da una cartella che è diversa da quella cartella di dominio applicazione corrente si, creare il nuovo dominio applicazione con la cartella DLL specifiche del percorso di ricerca.

Ad esempio, la linea di creazione del dominio applicazione dal codice di cui sopra dovrebbe essere sostituito con:

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

In questo modo, tutte le DLL saranno automaically essere risolti da dllsSearchPath.

Answer 7

Mi ci è voluto un po 'per capire la risposta di @user1996230 quindi ho deciso di fornire un esempio più esplicito. Nell'esempio seguente creo un proxy per un oggetto caricato in un altro AppDomain e chiamo un metodo su quell'oggetto da un altro 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"}); 
}