public AssemblyLoader(string basePath, Func <AssemblyName, Assembly> onResolve = null) { BasePath = basePath; _onResolve = onResolve ?? (_ => null); if (basePath != null) { _dependencyContext = DependencyContextResolver.Resolve(basePath); _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(basePath), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); } else { _dependencyContext = DependencyContext.Default; _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); } _nativeLibraries = new ConcurrentDictionary <string, IntPtr>(); }
public Resolver(string path) { try { Log($"Image base path is {Path.GetDirectoryName(path)}"); Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); dependencyContext = DependencyContext.Load(Assembly); assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new DependencyModel.Resolution.PackageCompilationAssemblyResolver() }); loadContext = AssemblyLoadContext.GetLoadContext(Assembly); loadContext.Resolving += OnResolving; } catch (Exception ex) { Log($"AssemblyResolver error: {ex}"); } }
public AssemblyResolver(string path) { packagesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget/packages/"); // load main assembly var assemblyPath = Path.GetFullPath(path); Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath); Console.WriteLine($"Loaded function assembly {path}."); dependencyContext = DependencyContext.Load(Assembly); resolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(assemblyPath)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); loadContext = AssemblyLoadContext.GetLoadContext(Assembly); loadContext.Resolving += OnResolving; if (Default == null) { Default = this; } }
public NetCoreAssemblyRuntimeLoader(string path, IBenchmarkOutput trace) { _trace = trace; if (!File.Exists(path)) { trace.Error($"[NetCoreAssemblyRuntimeLoader] Unable to find requested assembly [{path}]"); return; } Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); if (Assembly == null) { trace.Error($"[NetCoreAssemblyRuntimeLoader] Found assembly [{path}], but was unable to load it."); return; } _dependencyContext = DependencyContext.Load(Assembly); _loadContext = AssemblyLoadContext.GetLoadContext(Assembly); _resolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext.Resolving += LoadContextOnResolving; _referencedAssemblies = new Lazy <Assembly[]>(LoadReferencedAssemblies); }
private IEnumerable <string> ResolveReferencePaths(ICompilationAssemblyResolver resolver, List <string> assemblies) { if (!resolver.TryResolveAssemblyPaths(this, assemblies)) { throw new InvalidOperationException(SR.Format(SR.LibraryLocationNotFound, Name)); } return(assemblies); }
private IEnumerable <string> ResolveReferencePaths(ICompilationAssemblyResolver resolver, List <string> assemblies) { if (!resolver.TryResolveAssemblyPaths(this, assemblies)) { throw new InvalidOperationException($"Cannot find compilation library location for package '{Name}'"); } return(assemblies); }
public AssemblyResolver(string path, List <string> referencedAssemblies, bool installDefaultResolveHandler = true) { this.installDefaultResolveHandler = installDefaultResolveHandler; if (Path.GetFileName(path) == "Orleans.Core.dll") { this.Assembly = typeof(RuntimeVersion).Assembly; } else { this.Assembly = Assembly.LoadFrom(path); } this.dependencyContext = DependencyContext.Load(this.Assembly); this.resolverRependencyContext = DependencyContext.Load(typeof(AssemblyResolver).Assembly); var codegenPath = Path.GetDirectoryName(new Uri(typeof(AssemblyResolver).Assembly.CodeBase).LocalPath); this.assemblyResolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(codegenPath), new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); #if NETCOREAPP this.loadContext = AssemblyLoadContext.GetLoadContext(this.Assembly); if (this.loadContext == AssemblyLoadContext.Default) { if (this.installDefaultResolveHandler) { AssemblyLoadContext.Default.Resolving += this.AssemblyLoadContextResolving; } } else { this.loadContext.Resolving += this.AssemblyLoadContextResolving; } #else if (this.installDefaultResolveHandler) { AppDomain.CurrentDomain.AssemblyResolve += this.ResolveAssembly; } #endif foreach (var assemblyPath in referencedAssemblies) { var libName = Path.GetFileNameWithoutExtension(assemblyPath); if (!string.IsNullOrWhiteSpace(libName)) { this.ReferenceAssemblyPaths[libName] = assemblyPath; } var asmName = AssemblyName.GetAssemblyName(assemblyPath); this.ReferenceAssemblyPaths[asmName.FullName] = assemblyPath; } }
static AssemblyLoader() { AssemblyLoadContext.Default.Resolving += Default_Resolving; AssemblyResolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(AppDomain.CurrentDomain.BaseDirectory), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); DependencyDLL = new ConcurrentDictionary <string, CompilationLibrary>(); }
private AssemblyResolver(Assembly assembly) { this.Assembly = assembly; this.assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(assembly.Location)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); this.loadContext = AssemblyLoadContext.GetLoadContext(this.Assembly); this.loadContext.Resolving += OnResolving; }
public CustomAssemblyResolver(AssemblyLoadContext assemblyLoadContext, string rootAssemblyPath) { var assembly = assemblyLoadContext.LoadFromAssemblyPath(rootAssemblyPath); this.dependencyContext = DependencyContext.Load(assembly); this.assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(rootAssemblyPath)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); }
public AssemblyResolver(string path) { this.Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); this.dependencyContext = DependencyContext.Load(this.Assembly); this.assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); this.loadContext = AssemblyLoadContext.GetLoadContext(this.Assembly); this.loadContext.Resolving += OnResolving; }
public NetCoreAssemblyRuntimeLoader(Assembly assembly, IBenchmarkOutput trace) { _trace = trace; Assembly = assembly; _dependencyContext = DependencyContext.Load(Assembly); _loadContext = AssemblyLoadContext.GetLoadContext(Assembly); _resolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(Assembly.CodeBase)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext.Resolving += LoadContextOnResolving; _referencedAssemblies = new Lazy <Assembly[]>(LoadReferencedAssemblies); }
void Initialize(Assembly assembly) { dependencyContext = DependencyContext.Load(assembly); assemblyFileNameToLibraryMap = dependencyContext.RuntimeLibraries .Where(lib => lib.RuntimeAssemblyGroups?.Count > 0) .Select(lib => Tuple.Create(lib, lib.RuntimeAssemblyGroups.FirstOrDefault(grp => grp.Runtime == CurrentRuntime || string.IsNullOrEmpty(grp.Runtime)))) .Where(tuple => tuple.Item2 != null && tuple.Item2.AssetPaths != null) .SelectMany(tuple => tuple.Item2.AssetPaths.Where(x => x != null).Select(path => Tuple.Create(tuple.Item1, Path.GetFileNameWithoutExtension(path)))) .ToDictionaryIgnoringDuplicateKeys(tuple => tuple.Item2, tuple => tuple.Item1, StringComparer.OrdinalIgnoreCase); assemblyResolver = new XunitPackageCompilationAssemblyResolver(); loadContext = AssemblyLoadContext.GetLoadContext(assembly); loadContext.Resolving += OnResolving; }
public AssemblyResolver(string path) { this._assembly = new Lazy <Assembly>(() => AssemblyLoadContext.Default.LoadFromAssemblyPath(path), true); this._dependencyContext = new Lazy <DependencyContext>(() => DependencyContext.Load(this.Assembly), true); this._assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); this._loadContext = new Lazy <AssemblyLoadContext>(() => AssemblyLoadContext.GetLoadContext(this.Assembly), true); }
public DependencyAwareAssemblyLoader(Assembly root) { Assembly = root ?? throw new ArgumentNullException(nameof(root)); _resolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(root.Location)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _dependencyContext = DependencyContext.Load(root); _assemblyLoadContext = AssemblyLoadContext.GetLoadContext(root); _assemblyLoadContext.Resolving += Resolve; }
public PluginAssemblyResolver(string path) { _loadContext = AssemblyLoadContext.GetLoadContext(typeof(PluginAssemblyResolver).Assembly); Assembly = _loadContext.LoadFromAssemblyPath(path); _dependencyContext = DependencyContext.Load(Assembly); _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext.Resolving += OnResolving; _loadContext.Unloading += OnUnloading; }
public Assembly Load(string assemblyPath) { var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath); _dependencyContext = DependencyContext.Load(assembly); _assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(assemblyPath)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext = AssemblyLoadContext.GetLoadContext(assembly); _loadContext.Resolving += OnResolving; return(assembly); }
public DependencyResolver(Assembly assembly) { _assembly = assembly; _dependencyContext = DependencyContext.Load(_assembly); _assemblyResolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(assembly.Location)), //new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext = AssemblyLoadContext.GetLoadContext(_assembly); _loadContext.Resolving += OnResolving; }
/// <summary> /// Creates new instance to dynamic load an assembly /// </summary> /// <param name="assemblyPath">The full path to assembly</param> public AssemblyLoader(string assemblyPath) { // load assembly var path = Path.GetDirectoryName(assemblyPath); this.Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath); this.LoadContext = AssemblyLoadContext.GetLoadContext(this.Assembly); // not dependencies => load referenced assembies if (!File.Exists(Path.Combine(path, $"{Path.GetFileNameWithoutExtension(assemblyPath)}.deps.json"))) { this.Assembly.GetReferencedAssemblies().ToList().ForEach(assemblyName => this.LoadContext.LoadFromAssemblyPath(Path.Combine(path, $"{assemblyName.Name}.dll"))); return; } this.DependencyContext = DependencyContext.Load(this.Assembly); this.AssemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(path), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); this.LoadContext.Resolving += (loadContext, assemblyName) => { var runtimeLib = this.DependencyContext.RuntimeLibraries.FirstOrDefault(runtime => string.Equals(runtime.Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase)); if (runtimeLib != null) { var compilationLib = new CompilationLibrary( runtimeLib.Type, runtimeLib.Name, runtimeLib.Version, runtimeLib.Hash, runtimeLib.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths), runtimeLib.Dependencies, runtimeLib.Serviceable ); var assemblyPaths = new List <string>(); this.AssemblyResolver.TryResolveAssemblyPaths(compilationLib, assemblyPaths); if (assemblyPaths.Count > 0) { return(loadContext.LoadFromAssemblyPath(assemblyPaths[0])); } } return(null); }; }
public AssemblyResolver(ILogger logger, string path) { _logger = logger; Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); _dependencyContext = DependencyContext.Load(Assembly); _assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext = AssemblyLoadContext.GetLoadContext(Assembly); _loadContext.Resolving += OnResolving; }
public AssemblyResolver(string path) { Assemblies = Directory.EnumerateFiles(path) .Where(i => i.EndsWith(".dll")) .Select(i => AssemblyLoadContext.Default.LoadFromAssemblyPath(i)) .ToArray(); this.assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); AssemblyLoadContext.Default.Resolving += OnResolving; dependencyContexts = Assemblies.Select(i => DependencyContext.Load(i)) .Where(i => i != null).ToArray(); }
/// <summary> /// Initializes a new instance of the <see cref="NetCoreAssemblyDependencyResolver"/> class. /// </summary> /// <param name="assemblyFilePath">The path to the assembly</param> public NetCoreAssemblyDependencyResolver(string assemblyFilePath) { var assembly = LoadFromAssemblyPath(assemblyFilePath); assemblyFolder = Path.GetDirectoryName(assemblyFilePath); assemblyResolver = new XunitPackageCompilationAssemblyResolver(); dependencyContext = DependencyContext.Load(assembly); var compatibleRuntimes = default(HashSet <string>); var currentRuntime = RuntimeEnvironment.GetRuntimeIdentifier(); var fallbacks = dependencyContext.RuntimeGraph.FirstOrDefault(x => string.Equals(x.Runtime, currentRuntime, StringComparison.OrdinalIgnoreCase)); if (fallbacks != null) { compatibleRuntimes = new HashSet <string>(fallbacks.Fallbacks, StringComparer.OrdinalIgnoreCase); } else { compatibleRuntimes = new HashSet <string>(StringComparer.OrdinalIgnoreCase); } compatibleRuntimes.Add(currentRuntime); compatibleRuntimes.Add(string.Empty); managedAssemblyMap = dependencyContext.RuntimeLibraries .Where(lib => lib.RuntimeAssemblyGroups?.Count > 0) .Select(lib => Tuple.Create(lib, lib.RuntimeAssemblyGroups.FirstOrDefault(libGroup => compatibleRuntimes.Contains(libGroup.Runtime)))) .Where(tuple => tuple.Item2?.AssetPaths != null) .SelectMany(tuple => tuple.Item2.AssetPaths.Where(x => x != null).Select(path => Tuple.Create(Path.GetFileNameWithoutExtension(path), Tuple.Create(tuple.Item1, tuple.Item2)))) .ToDictionaryIgnoringDuplicateKeys(tuple => tuple.Item1, tuple => tuple.Item2, StringComparer.OrdinalIgnoreCase); unmanagedAssemblyMap = dependencyContext.RuntimeLibraries .Where(lib => lib.NativeLibraryGroups?.Count > 0) .Select(lib => Tuple.Create(lib, lib.NativeLibraryGroups.FirstOrDefault(libGroup => compatibleRuntimes.Contains(libGroup.Runtime)))) .Where(tuple => tuple.Item2?.AssetPaths != null) .SelectMany(tuple => tuple.Item2.AssetPaths.Where(x => x != null).Select(path => Tuple.Create(Path.GetFileName(path), Tuple.Create(tuple.Item1, tuple.Item2)))) .ToDictionaryIgnoringDuplicateKeys(tuple => tuple.Item1, tuple => tuple.Item2, StringComparer.OrdinalIgnoreCase); Default.Resolving += OnResolving; }
/// <summary> /// Initializes a new instance of <see cref="AssemblyContext"/> /// </summary> /// <param name="assembly">Assembly the context is for</param> public AssemblyContext(Assembly assembly) { Assembly = assembly; DependencyContext = DependencyContext.Load(assembly); var codeBaseUri = new Uri(assembly.CodeBase); var basePath = Path.GetDirectoryName(codeBaseUri.LocalPath); _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(basePath), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver(), new NuGetFallbackFolderAssemblyResolver(), new PackageRuntimeStoreAssemblyResolver() }); AssemblyLoadContext = AssemblyLoadContext.GetLoadContext(assembly); AssemblyLoadContext.Resolving += OnResolving; }
public AssemblyResolver(string path) { Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); _dependencyContext = DependencyContext.Load(Assembly); var nugetPackagePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".nuget\packages"); var dotnetPackagePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"dotnet\shared"); _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new PackageCompilationAssemblyResolver(nugetPackagePath), new PackageCompilationAssemblyResolver(dotnetPackagePath), }); _loadContext = AssemblyLoadContext.GetLoadContext(Assembly); _loadContext.Resolving += OnResolving; }
public AssemblyResolver() { _resolverRependencyContext = DependencyContext.Load(typeof(AssemblyResolver).Assembly); var codegenPath = Path.GetDirectoryName(new Uri(typeof(AssemblyResolver).Assembly.Location).LocalPath); _assemblyResolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(codegenPath), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly; _loadContext = AssemblyLoadContext.GetLoadContext(typeof(AssemblyResolver).Assembly); _loadContext.Resolving += AssemblyLoadContextResolving; if (_loadContext != AssemblyLoadContext.Default) { AssemblyLoadContext.Default.Resolving += AssemblyLoadContextResolving; } }
public static Assembly LoadPlugin(string path) { Assembly assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); _dependencyContext = DependencyContext.Load(assembly); _assemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(path)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); _loadContext = AssemblyLoadContext.GetLoadContext(assembly); if (_loadContext != null) { _loadContext.Resolving += OnResolving; } return(assembly); }
static AssemblyResolver() { allLibraries = Directory.GetFiles(PlatformServices.Default.Application.ApplicationBasePath, "*.deps.json") .SelectMany(deps => { var reader = new DependencyContextJsonReader(); using (var json = File.OpenRead(deps)) { return(reader.Read(json).RuntimeLibraries); } }) .Distinct(new RuntimeLibraryComparer()) .ToList(); assemblyResolver = new CompositeCompilationAssemblyResolver (new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(PlatformServices.Default.Application.ApplicationBasePath)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver(FindPackageRoot()) }); }
/// <summary> /// Initializes a new instance of the <see cref="TestMethodInfo"/> class. /// </summary> private TestMethodInfo(Configuration configuration) { #if NET || NETCOREAPP3_1 this.Assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(configuration.AssemblyToBeAnalyzed); this.LoadContext = AssemblyLoadContext.GetLoadContext(this.Assembly); this.DependencyContext = DependencyContext.Load(this.Assembly); this.AssemblyResolver = new CompositeCompilationAssemblyResolver(new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(Path.GetDirectoryName(configuration.AssemblyToBeAnalyzed)), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); this.LoadContext.Resolving += this.OnResolving; #else this.Assembly = Assembly.LoadFrom(configuration.AssemblyToBeAnalyzed); #endif (this.Method, this.Name) = GetTestMethod(this.Assembly, configuration.TestMethodName); this.InitMethod = GetTestSetupMethod(this.Assembly, typeof(TestInitAttribute)); this.DisposeMethod = GetTestSetupMethod(this.Assembly, typeof(TestDisposeAttribute)); this.IterationDisposeMethod = GetTestSetupMethod(this.Assembly, typeof(TestIterationDisposeAttribute)); }
public AssemblyResolver() { this.resolverRependencyContext = DependencyContext.Load(typeof(AssemblyResolver).Assembly); var codegenPath = Path.GetDirectoryName(new Uri(typeof(AssemblyResolver).Assembly.CodeBase).LocalPath); this.assemblyResolver = new CompositeCompilationAssemblyResolver( new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(codegenPath), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }); AppDomain.CurrentDomain.AssemblyResolve += this.ResolveAssembly; #if NETCOREAPP this.loadContext = AssemblyLoadContext.GetLoadContext(typeof(AssemblyResolver).Assembly); this.loadContext.Resolving += this.AssemblyLoadContextResolving; if (this.loadContext != AssemblyLoadContext.Default) { AssemblyLoadContext.Default.Resolving += this.AssemblyLoadContextResolving; } #endif }
public CompositeCompilationAssemblyResolver(ICompilationAssemblyResolver[] resolvers) { _resolvers = resolvers; }
private static void SetupInterceptorsDependencyResolver(string assemblyFolder, Assembly interceptorsAssembly) { if (Directory.GetFiles(assemblyFolder, "*.deps.json").Length > 0) { // this method loads assemblies from both assembly folder and nuget cache and requires deps.json file // see https://github.com/dotnet/runtime/issues/18527#issuecomment-611499261 var dependencyContext = DependencyContext.Load(interceptorsAssembly); var resolver = new ICompilationAssemblyResolver[] { new AppBaseCompilationAssemblyResolver(assemblyFolder), new ReferenceAssemblyPathResolver(), new PackageCompilationAssemblyResolver() }; var assemblyResolver = new CompositeCompilationAssemblyResolver(resolver); var loadContext = AssemblyLoadContext.GetLoadContext(interceptorsAssembly); loadContext !.Resolving += (AssemblyLoadContext context, AssemblyName name) => { bool NamesMatch(RuntimeLibrary runtime) { var res = string.Equals(runtime.Name, name.Name, StringComparison.OrdinalIgnoreCase); if (!res) { foreach (var group in runtime.RuntimeAssemblyGroups) { foreach (var l in group.RuntimeFiles) { if (Path.GetFileNameWithoutExtension(l.Path) == name.Name) { return(true); } } } } return(res); } var library = dependencyContext.RuntimeLibraries.FirstOrDefault(NamesMatch); if (library == null) { return(null); } var wrapper = new CompilationLibrary( library.Type, library.Name, library.Version, library.Hash, library.RuntimeAssemblyGroups.SelectMany(g => g.AssetPaths), library.Dependencies, library.Serviceable); var assemblies = new List <string>(); assemblyResolver.TryResolveAssemblyPaths(wrapper, assemblies); var assembly = assemblies.FirstOrDefault(a => Path.GetFileNameWithoutExtension(a) == name.Name); Console.WriteLine($"Load from: {assembly}"); return(assembly == null ? null : Assembly.LoadFile(assembly)); }; } else { // alternative approach supports loading from assembly folder without deps.json file AssemblyLoadContext.Default.Resolving += (context, name) => { // TODO: verbose logging Console.WriteLine($"AssemblyResolve: {name}"); // as we know only assembly name, not file name (written in deps.json) - we try to guess it var probePath1 = Path.Combine(assemblyFolder, name.Name + ".dll"); var probePath2 = Path.Combine(assemblyFolder, name.Name + ".exe"); if (File.Exists(probePath1)) { Console.WriteLine($"Found at: {probePath1}"); return(Assembly.LoadFile(probePath1)); } if (File.Exists(probePath2)) { Console.WriteLine($"Found at: {probePath2}"); return(Assembly.LoadFile(probePath2)); } return(null); }; } }