Czy istnieje sposób na wymuszenie załadowania wszystkich przywoływanych zestawów do domeny aplikacji?

Question

Moje projekty są ustawione tak:

• Project "Definicja"
• Projekt "Wdrożenie"
• Project "Konsument"

projektowe odniesienia "konsument" zarówno "Definition" i "Implementacja", ale nie odnosi się statycznie do żadnego typu w "Implementacji".

Po uruchomieniu aplikacji, Project „Konsument” wywołuje statyczną metodę w „Definicja”, który musi znaleźć typy w „realizacji”

Czy istnieje sposób mogę zmusić żadnego odwołuje zespół do być załadowany do Domena aplikacji bez znajomości ścieżki lub nazwy, a najlepiej bez użycia pełnowartościowej architektury IOC?

Answer 1

To wydawało się rade:

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

Jak zauważył Jon, idealnym rozwiązaniem byłoby potrzeba aby powrócić do zależności dla każdego z załadowanych zespołów, ale w moim konkretnym scenariuszu nie muszę się o to martwić.

---

Aktualizacja: Managed Extensibility Framework (System.ComponentModel) zawarte w .NET 4 ma znacznie lepsze zaplecze dla realizacji takich rzeczy.

Answer 2

Możesz użyć Assembly.GetReferencedAssemblies, aby uzyskać AssemblyName[], a następnie wywołać Assembly.Load(AssemblyName) na każdym z nich. Musisz recurse, oczywiście - ale najlepiej śledzenie zespołów już załadowany :)

Answer 3

Jeśli użyjesz Fody.Costura lub innego rozwiązania do łączenia zespołów, zaakceptowana odpowiedź nie będzie działać.

Następujące ładuje zespoły referencyjne dowolnego aktualnie załadowanego zespołu. Rekursja jest pozostawiona tobie.

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

Chciałam udostępnić przykład rekursywny. Dzwonię metodę LoadReferencedAssembly w moim procedury startowej tak:

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

Jest to metoda rekurencyjna:

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

Widząc jak miałem załadować montaż + zależności od konkretnej ścieżki dzisiaj napisał tę klasę, aby to zrobić.

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