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