Gibt es eine Möglichkeit zum Erzwingen, dass alle referenzierten Assemblys in die App-Domäne geladen werden?

Question

Meine Projekte sind wie folgt aufgebaut:

• Projekt "Definition"
• Projekt "Implementierung"
• Projekt "Consumer"

Projekt "Consumer" Referenzen sowohl "Definition" und "Implementierung", referenziert jedoch keine Typen in "Implementierung".

Wenn die Anwendung gestartet, Projekt „Consumer“, ruft eine statische Methode in „Definition“, die Typen in „Implementierung“

Gibt es finden muss eine Weise, die ich jede referenzierte Assembly in dem zu ladende zwingen kann, App Domain ohne den Pfad oder den Namen zu kennen und vorzugsweise ohne ein vollwertiges IOC-Framework zu verwenden?

Answer 1

Dies schien den Trick zu tun:

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

Als Jon erwähnt, ist die ideale Lösung müssten um in die Abhängigkeiten für jede der geladenen Assemblies zu rekapitulieren, aber in meinem speziellen Szenario muss ich mich nicht darum kümmern.

---

Update: Die Managed Extensibility Framework (System.ComponentModel) in .NET 4 enthalten hat viel bessere Möglichkeiten für Dinge wie dies zu erreichen.

Answer 2

Sie können Assembly.GetReferencedAssemblies verwenden, um eine AssemblyName[] zu erhalten, und rufen Sie dann Assembly.Load(AssemblyName) auf jedem von ihnen. Sie werden Rekursion benötigen, natürlich - aber vorzugsweise die Verfolgung von Baugruppen haben Sie bereits geladen :)

Answer 3

Wenn Sie Fody.Costura oder eine andere Assembly-Merging-Lösung verwenden, funktioniert die akzeptierte Antwort nicht.

Im Folgenden werden die referenzierten Assemblys aller derzeit geladenen Assembly geladen. Rekursion bleibt dir überlassen.

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

wollte nur ein rekursives Beispiel teilen. Ich rufe die LoadReferencedAssembly Methode in meiner Startroutine wie folgt aus:

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

Dies ist die rekursive Methode ist:

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

Da ich heute eine Assembly + Abhängigkeiten von einem bestimmten Pfad zu laden hatte ich schrieb diese Klasse, um es zu tun.

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