¿Hay alguna manera de forzar que todos los ensamblados a los que se hace referencia se carguen en el dominio de la aplicación?

Question

Mis proyectos se establecen así:

• Proyecto "Definición"
• Proyecto "Aplicación"
• Proyecto "consumidor"

proyecto hace referencia a "consumidor" ambos "Definición" y "Implementación", pero no hace referencia estática a ningún tipo en "Implementación".

Cuando se inicia la aplicación, el Proyecto "consumidor" llama a un método estático en "Definición", que necesita para encontrar tipos de "Aplicación"

¿Hay alguna manera de forzar cualquier ensamblaje de referencia para ser cargado en el ¿App Domain sin conocer la ruta o el nombre, y preferiblemente sin tener que usar un marco IOC completo?

Answer 1

Esto parecía hacer el truco:

 var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); 
     var loadedPaths = loadedAssemblies.Select(a => a.Location).ToArray(); 

     var referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); 
     var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList(); 
     toLoad.ForEach(path => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(path)))); 

Como se señaló Jon, la solución ideal sería necesario recurrir en las dependencias para cada uno de los ensamblados cargados, pero en mi escenario específico no tengo que preocuparme por ello.

---

Actualización: El Marco Extensibilidad Administrada (System.ComponentModel) incluido en .NET 4 tiene mucho mejores instalaciones para llevar a cabo este tipo de cosas.

Answer 2

Puede usar Assembly.GetReferencedAssemblies para obtener un AssemblyName[], y luego llamar al Assembly.Load(AssemblyName) en cada uno de ellos. Tendrá que recursivo, por supuesto - pero preferiblemente hacer el seguimiento de las asambleas que ya ha cargado :)

Answer 3

Si utiliza Fody.Costura, o cualquier otra solución de montaje fusión, la respuesta aceptada no va a funcionar.

Las siguientes cargas de los ensamblados de referencia de cualquier Asamblea cargado en ese momento. La recursividad te queda a ti.

var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); 

loadedAssemblies 
    .SelectMany(x => x.GetReferencedAssemblies()) 
    .Distinct() 
    .Where(y => loadedAssemblies.Any((a) => a.FullName == y.FullName) == false) 
    .ToList() 
    .ForEach(x => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(x))); 

Answer 4

solo queríamos compartir un ejemplo recursivo. Voy a llamar al método LoadReferencedAssembly en mi rutina de inicio de esta manera:

foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) 
{ 
    this.LoadReferencedAssembly(assembly); 
} 

Este es el método recursivo:

private void LoadReferencedAssembly(Assembly assembly) 
{ 
    foreach (AssemblyName name in assembly.GetReferencedAssemblies()) 
    { 
     if (!AppDomain.CurrentDomain.GetAssemblies().Any(a => a.FullName == name.FullName)) 
     { 
      this.LoadReferencedAssembly(Assembly.Load(name)); 
     } 
    } 
} 

Answer 5

En vista de que he tenido que cargar un ensamblado + dependencias de una ruta específica hoy escribió esta clase para hacerlo.

public static class AssemblyLoader 
{ 
    private static readonly ConcurrentDictionary<string, bool> AssemblyDirectories = new ConcurrentDictionary<string, bool>(); 

    static AssemblyLoader() 
    { 
     AssemblyDirectories[GetExecutingAssemblyDirectory()] = true; 
     AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly; 

    } 

    public static Assembly LoadWithDependencies(string assemblyPath) 
    { 
     AssemblyDirectories[Path.GetDirectoryName(assemblyPath)] = true; 
     return Assembly.LoadFile(assemblyPath); 
    } 

    private static Assembly ResolveAssembly(object sender, ResolveEventArgs args) 
    { 
     string dependentAssemblyName = args.Name.Split(',')[0] + ".dll"; 
     List<string> directoriesToScan = AssemblyDirectories.Keys.ToList(); 

     foreach (string directoryToScan in directoriesToScan) 
     { 
      string dependentAssemblyPath = Path.Combine(directoryToScan, dependentAssemblyName); 
      if (File.Exists(dependentAssemblyPath)) 
       return LoadWithDependencies(dependentAssemblyPath); 
     } 
     return null; 
    } 

    private static string GetExecutingAssemblyDirectory() 
    { 
     string codeBase = Assembly.GetExecutingAssembly().CodeBase; 
     var uri = new UriBuilder(codeBase); 
     string path = Uri.UnescapeDataString(uri.Path); 
     return Path.GetDirectoryName(path); 
    } 
}