private static ConcurrentDictionary <string, AdditionalAssemblyServerSide> DiscoverAdditionalAssemblies()
{
var results = new ConcurrentDictionary <string, AdditionalAssemblyServerSide>(StringComparer.OrdinalIgnoreCase);
foreach (var path in Directory.GetFiles(AppContext.BaseDirectory, "*.dll"))
{
if (Logger.IsInfoEnabled)
{
Logger.Info($"Attempting to load additional assembly from '{path}'.");
}
try
{
var name = AssemblyLoadContext.GetAssemblyName(path);
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
var reference = CreateMetadataReferenceFromAssembly(assembly);
results.TryAdd(name.Name, new AdditionalAssemblyServerSide(name, assembly, reference, AdditionalAssemblyType.BaseDirectory));
if (Logger.IsInfoEnabled)
{
Logger.Info($"Loaded additional assembly from '{path}' and registered it under '{name.Name}'.");
}
}
catch (Exception e)
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations($"Could not load additional assembly from '{path}'.", e);
}
}
}
return(results);
}
public async Task Load_Works()
{
var testContext = await SetupLoadedPluginTextContext();
var loadContext = testContext.Sut();
var assemblyLoadStrategy = testContext.GetMock <IAssemblyLoadStrategy>();
var initialPluginLoadDirectory = testContext.InitialPluginLoadDirectory;
var pluginLoadContext = testContext.PluginLoadContext;
var pluginDependencyContext = testContext.GetMock <IPluginDependencyContext>();
var newtonsoftAssemblyPath = Path.Combine(GetPathToAssemblies(), "Newtonsoft.Json.dll");
var newtonsoftAssembly = Assembly.LoadFile(newtonsoftAssemblyPath);
var newtonsoftAssemblyName = AssemblyLoadContext.GetAssemblyName(newtonsoftAssemblyPath);
assemblyLoadStrategy.Setup(a => a.LoadAssembly(initialPluginLoadDirectory, newtonsoftAssemblyName, pluginDependencyContext.Object,
It.IsAny <Func <string, AssemblyName, ValueOrProceed <AssemblyFromStrategy> > >(),
It.IsAny <Func <string, AssemblyName, ValueOrProceed <AssemblyFromStrategy> > >(),
It.IsAny <Func <string, AssemblyName, ValueOrProceed <RuntimeAssemblyShim> > >()))
.Returns(new AssemblyFromStrategy
{
Assembly = newtonsoftAssembly,
CanBeReleased = true
});
var result = InvokeProtectedMethodOnLoadContextAndGetResult <Assembly>(
loadContext,
"Load",
new object[] { newtonsoftAssemblyName });
Assert.IsNotNull(result);
}
private Assembly TryResolveAssemblyFromPaths(AssemblyLoadContext context, AssemblyName assemblyName, IEnumerable <string> searchPaths)
{
foreach (var cultureSubfolder in string.IsNullOrEmpty(assemblyName.CultureName)
// If no culture is specified, attempt to load directly from
// the known dependency paths.
? new[] { string.Empty }
// Search for satellite assemblies in culture subdirectories
// of the assembly search directories, but fall back to the
// bare search directory if that fails.
: new[] { assemblyName.CultureName, string.Empty })
{
foreach (var searchPath in searchPaths)
{
var candidatePath = Path.Combine(searchPath,
cultureSubfolder,
$"{assemblyName.Name}.dll");
if (IsAssemblyAlreadyLoaded(candidatePath) ||
!FileSystems.Default.FileExists(candidatePath))
{
continue;
}
AssemblyName candidateAssemblyName = AssemblyLoadContext.GetAssemblyName(candidatePath);
if (candidateAssemblyName.Version >= assemblyName.Version)
{
return(LoadAndCache(context, candidatePath));
}
}
}
return(null);
}
/// <summary>
/// 在当前运行目录下，查找所有dll
/// </summary>
/// <returns></returns>
public List <Assembly> GetAssembliesFromFolder()
{
var assemblies = new List <Assembly>();
#if CORE
var files = Directory.GetFiles($"{AppContext.BaseDirectory}", "*.dll");
#else
var files = Directory.GetFiles($"{AppDomain.CurrentDomain.BaseDirectory}", "*.dll");
#endif
foreach (var file in files)
{
try
{
#if CORE
assemblies.Add(Assembly.Load(AssemblyLoadContext.GetAssemblyName(file)));
#else
assemblies.Add(Assembly.LoadFrom(file));
#endif
}
catch (Exception)
{
// ignored 失败的原因是非托管程序
}
}
return(assemblies);
}
public POCOParser(string assemblyPath, string classFullName)
{
var asmName = AssemblyLoadContext.GetAssemblyName(assemblyPath);
var asm = Assembly.LoadFrom(assemblyPath);
_type = asm.GetType(classFullName);
}
private static ContainerConfiguration WithAssembliesInPath(ContainerConfiguration configuration,
string path, AttributedModelProvider conventions,
SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
var assemblies = new List <Assembly>();
var assemblieFiles = Directory.GetFiles(path, "*.dll", searchOption);
foreach (var assemblyFile in assemblieFiles)
{
try
{
var ctx = new MarvinAssemblyLoadContext();
AssemblyLoadContext.InitializeDefaultContext(ctx);
var name = AssemblyLoadContext.GetAssemblyName(assemblyFile);
var asm = Assembly.Load(name);
assemblies.Add(asm);
}
catch (Exception e)
{
Console.Out.WriteLine("Error loading module: " + e.Message + " from: " + path);
}
}
return(configuration.WithAssemblies(assemblies, conventions));
}
public static void GetAssemblyNameTest_ValidAssembly()
{
var expectedName = typeof(ISet <>).GetTypeInfo().Assembly.GetName();
var actualAsmName = AssemblyLoadContext.GetAssemblyName("System.Runtime.dll");
Assert.Equal(expectedName.FullName, actualAsmName.FullName);
}
/// <summary>
/// Load the assembly found at the given path in the reflection context and return assembly metadata
/// </summary>
/// <param name="assemblyPath">The full path to the assembly file.</param>
/// <returns>Assembly metadata if the assembly is loaded successfully, or null if there are load errors.</returns>
public AssemblyMetadata GetReflectedAssemblyFromFile(string assemblyPath)
{
if (string.IsNullOrWhiteSpace(assemblyPath))
{
throw new ArgumentException("assemblyPath");
}
AssemblyMetadata result = null;
try
{
#if !NETSTANDARD
return(new AssemblyMetadata(Assembly.ReflectionOnlyLoadFrom(assemblyPath)));
#else
return(new AssemblyMetadata(AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyPath)));
}
catch (System.IO.FileLoadException ex) when(ex != null && string.Equals(ex.Message, "Assembly with same name is already loaded"))
{
var assemblyName = AssemblyLoadContext.GetAssemblyName(assemblyPath);
var assembly = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.GetName().Name == assemblyName?.Name).FirstOrDefault();
if (assembly != null)
{
result = new AssemblyMetadata(assembly);
}
#endif
}
catch
{
}
return(result);
}
private bool TryGetAssemblyName(string path, out AssemblyName assemblyName)
{
assemblyName = null;
if (!File.Exists(path))
{
// Path might be bin\placeholder\** if assembly came from a project-to-project reference. Since those
// assemblies are found in the current output directory, just ignore non-existent paths. If this path
// came from somewhere else and assembly is used, loading will fail soon enough.
return(false);
}
// From http://msdn.microsoft.com/en-us/library/ms173100.aspx and AssemblyHelper.IsAssemblyManaged().
try
{
assemblyName = AssemblyLoadContext.GetAssemblyName(path);
return(true);
}
catch (FileNotFoundException)
{
// The file cannot be found (should be redundant).
}
catch (BadImageFormatException)
{
// The file is not an assembly.
}
catch (FileLoadException)
{
// The assembly has already been loaded.
}
return(false);
}
private static Assembly TryResolveAssemblyFromPaths_NoLock(AssemblyLoadContext context, AssemblyName assemblyName, string searchPath)
{
foreach (var cultureSubfolder in string.IsNullOrEmpty(assemblyName.CultureName)
// If no culture is specified, attempt to load directly from
// the known dependency paths.
? new[] { string.Empty }
// Search for satellite assemblies in culture subdirectories
// of the assembly search directories, but fall back to the
// bare search directory if that fails.
: new[] { assemblyName.CultureName, string.Empty })
{
foreach (var extension in s_extensions)
{
var candidatePath = Path.Combine(
searchPath, cultureSubfolder, $"{assemblyName.Name}.{extension}");
var isAssemblyLoaded = s_pathsToAssemblies.ContainsKey(candidatePath);
if (isAssemblyLoaded || !File.Exists(candidatePath))
{
continue;
}
var candidateAssemblyName = AssemblyLoadContext.GetAssemblyName(candidatePath);
if (candidateAssemblyName.Version < assemblyName.Version)
{
continue;
}
return(LoadAndCache_NoLock(context, candidatePath));
}
}
return(null);
}
protected virtual AssemblyInfo ResolveAssembly(AssemblyName name, FileSystemInfo[] files)
{
if (files.Any())
{
var libraries = DependencyContext.Default.RuntimeLibraries;
foreach (var file in files)
{
var assemblyName = AssemblyLoadContext.GetAssemblyName(file.FullName);
if (!libraries.Any(l => this.IsCandidateLibrary(l, name)))
{
try
{
var info = this.LoadAssembly(file.FullName, assemblyName);
if (info != null)
{
return(info);
}
}
catch
{
// Consume exception. Assembly failing to load should not fail all assemblies.
}
}
}
}
return(null);
}
private string GetInProcDataCollectionRunsettingsFile(bool disableAppDomain)
{
var runSettings = Path.Combine(Path.GetTempPath(), "test_" + Guid.NewGuid() + ".runsettings");
var inprocasm = this.testEnvironment.GetTestAsset("SimpleDataCollector.dll");
#if !NET451
var assemblyName = AssemblyLoadContext.GetAssemblyName(inprocasm);
#else
var assemblyName = AssemblyName.GetAssemblyName(inprocasm);
#endif
var fileContents = @"<RunSettings>
<InProcDataCollectionRunSettings>
<InProcDataCollectors>
<InProcDataCollector friendlyName='Test Impact' uri='InProcDataCollector://Microsoft/TestImpact/1.0' assemblyQualifiedName='SimpleDataCollector.SimpleDataCollector, {0}' codebase='{1}'>
<Configuration>
<Port>4312</Port>
</Configuration>
</InProcDataCollector>
</InProcDataCollectors>
</InProcDataCollectionRunSettings>
<RunConfiguration>
<DisableAppDomain>" + disableAppDomain + @"</DisableAppDomain>
</RunConfiguration>
</RunSettings>";
fileContents = string.Format(fileContents, assemblyName, inprocasm);
File.WriteAllText(runSettings, fileContents);
return(runSettings);
}
// Find the assembly under 'gacRoot' and select the latest version.
private bool FindInGac(string gacRoot, AssemblyName assemblyName, out string assemblyPath)
{
bool assemblyFound = false;
assemblyPath = null;
char dirSeparator = IO.Path.DirectorySeparatorChar;
string tempAssemblyDirPath = $"{gacRoot}{dirSeparator}{assemblyName.Name}";
if (Directory.Exists(tempAssemblyDirPath))
{
//Enumerate all directories, sort by name and select the last. This selects the latest version.
var chosenVersionDirectory = Directory.GetDirectories(tempAssemblyDirPath).OrderBy(d => d).LastOrDefault();
if (!String.IsNullOrEmpty(chosenVersionDirectory))
{
//Select first or default as the directory will contain only one assembly. If nothing then default is null;
var foundAssemblyPath = Directory.GetFiles(chosenVersionDirectory, $"{assemblyName.Name}*").FirstOrDefault();
if (!String.IsNullOrEmpty(foundAssemblyPath))
{
AssemblyName asmNameFound = AssemblyLoadContext.GetAssemblyName(foundAssemblyPath);
if (IsAssemblyMatching(assemblyName, asmNameFound))
{
assemblyPath = foundAssemblyPath;
assemblyFound = true;
}
}
}
}
return(assemblyFound);
}
private string GetInProcDataCollectionRunsettingsFile()
{
var runSettings = Path.Combine(Path.GetDirectoryName(testEnvironment.GetTestAsset(DataCollectorTests.InProDataCollectorTestProject)), "runsettingstest.runsettings");
var inprocasm = testEnvironment.GetTestAsset("SimpleDataCollector.dll");
#if !NET46
var assemblyName = AssemblyLoadContext.GetAssemblyName(inprocasm);
#else
var assemblyName = AssemblyName.GetAssemblyName(inprocasm);
#endif
var fileContents = @"<RunSettings>
<InProcDataCollectionRunSettings>
<InProcDataCollectors>
<InProcDataCollector friendlyName='Test Impact' uri='InProcDataCollector://Microsoft/TestImpact/1.0' assemblyQualifiedName='SimpleDataCollector.SimpleDataCollector, {0}' codebase='{1}'>
<Configuration>
<Port>4312</Port>
</Configuration>
</InProcDataCollector>
</InProcDataCollectors>
</InProcDataCollectionRunSettings>
</RunSettings>";
fileContents = string.Format(fileContents, assemblyName, inprocasm);
File.WriteAllText(runSettings, fileContents);
return(runSettings);
}
IEnumerable <Assembly> TryLoadAssemblies([NotNull] IEnumerable <string> filenames)
{
AssemblyLoadContext.Default.Resolving += AssemblyResolver.OnResolving;
foreach (string assemblyFile in filenames.Where(File.Exists))
{
Assembly assembly;
try
{
var assemblyName = AssemblyLoadContext.GetAssemblyName(assemblyFile);
if (IsInRuntimeLibraries(assemblyName))
{
assembly = Assembly.Load(assemblyName);
}
else
{
assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyFile);
}
}
catch (BadImageFormatException)
{
// fail on native images...
continue;
}
catch (FileLoadException ex)
{
this._logger.Value.Warning(ex, "Failure Loading Assembly File {AssemblyFile}", assemblyFile);
continue;
}
yield return(assembly);
}
}
/// <summary>
/// Loads the assembly from the specified path.
/// </summary>
/// <param name="path">
/// The path.
/// </param>
/// <returns>
/// The <see cref="IEnumerable{T}"/> of assemblies.
/// </returns>
private static IEnumerable <Assembly> LoadAssembly(string path)
{
Assembly result;
try
{
#if NETSTANDARD1_5
result = PluginResolver.DefaultPluginAssemblies.FirstOrDefault(a => a.Location.Equals(path)) ?? PluginResolver.DefaultAssemblyLoadContext.LoadFromAssemblyPath(path);
#elif NET45
result = DefaultPluginAssemblies.FirstOrDefault(a => a.Location.Equals(path)) ?? Assembly.LoadFrom(path);
#endif
}
catch
{
#if NETSTANDARD1_5
// DefaultAssemblyLoadContext.LoadFromAssemblyPath will throw when the assembly is already
// loaded. In that case, we can load it by its AssemblyName.
var name = AssemblyLoadContext.GetAssemblyName(path);
try
{
result = Assembly.Load(name);
}
catch
{
yield break;
}
#elif NET45
yield break;
#endif
}
yield return(result);
}
// Compute the size of MSIL files in a directory, in MegaBytes
// Top level only, excludes crossgen files.
private double GetMSILSize(string dir)
{
string[] files = Directory.GetFiles(dir);
long msilSize = 0;
foreach (string file in files)
{
if (file.EndsWith(".ni.dll") || file.EndsWith(".ni.exe"))
{
continue;
}
try
{
AssemblyLoadContext.GetAssemblyName(file);
}
catch (BadImageFormatException)
{
continue;
}
msilSize += new FileInfo(file).Length;
}
return(msilSize / MB);
}
/// <summary>
/// Facade for AssemblyName.GetAssemblyName(string)
/// </summary>
internal static AssemblyName GetAssemblyName(string assemblyPath)
{
#if CORECLR // AssemblyName.GetAssemblyName(assemblyPath) is not in CoreCLR
return(AssemblyLoadContext.GetAssemblyName(assemblyPath));
#else
return(AssemblyName.GetAssemblyName(assemblyPath));
#endif
}
internal static NuGetVersion GetAssemblyVersion(string path)
{
#if NET451
return(new NuGetVersion(AssemblyName.GetAssemblyName(path).Version));
#else
return(new NuGetVersion(AssemblyLoadContext.GetAssemblyName(path).Version));
#endif
}
/// <summary>
/// Gets the assembly name at a given location.
/// </summary>
/// <param name="assemblyPath"></param>
/// <returns></returns>
public static AssemblyName GetAssemblyName(string assemblyPath)
{
#if !NET451
return(AssemblyLoadContext.GetAssemblyName(assemblyPath));
#else
return(AssemblyName.GetAssemblyName(assemblyPath));
#endif
}
private Assembly Default_Resolving(AssemblyLoadContext aContext, AssemblyName aName)
{
foreach (var xRef in References)
{
var xName = AssemblyLoadContext.GetAssemblyName(xRef);
if (xName.Name == aName.Name)
{
return(aContext.LoadFromAssemblyPath(xRef));
}
}
foreach (var xRef in References)
{
var xKernelAssemblyDir = Path.GetDirectoryName(xRef);
var xAssemblyPath = Path.Combine(xKernelAssemblyDir, aName.Name);
if (File.Exists(xAssemblyPath + ".dll"))
{
return(aContext.LoadFromAssemblyPath(xAssemblyPath + ".dll"));
}
if (File.Exists(xAssemblyPath + ".exe"))
{
return(aContext.LoadFromAssemblyPath(xAssemblyPath + ".exe"));
}
}
//var xRequestingAssembly = Assembly.GetEntryAssembly();
//if (xRequestingAssembly != null) {
// // check for path in as requested dll is stored, this makes referenced dll project working
// var xPathAsRequested = Path.Combine(Path.GetDirectoryName(xRequestingAssembly.Location), aName.Name + ".dll");
// if (File.Exists(xPathAsRequested)) {
// return aContext.LoadFromAssemblyPath(xPathAsRequested);
// }
//}
// check for assembly in working directory
var xPathToCheck = Path.Combine(Directory.GetCurrentDirectory(), aName.Name + ".dll");
if (File.Exists(xPathToCheck))
{
return(aContext.LoadFromAssemblyPath(xPathToCheck));
}
foreach (var xDir in AssemblySearchDirs)
{
var xPath = Path.Combine(xDir, aName.Name + ".dll");
if (File.Exists(xPath))
{
return(aContext.LoadFromAssemblyPath(xPath));
}
xPath = Path.Combine(xDir, aName.Name + ".exe");
if (File.Exists(xPath))
{
return(aContext.LoadFromAssemblyPath(xPath));
}
}
return(null);
}
public static AssemblyName GetAssemblyName(string absoluteFilePath)
{
if (!System.IO.File.Exists(absoluteFilePath))
{
return(null);
}
return(AssemblyLoadContext.GetAssemblyName(absoluteFilePath));
}
private static void LoadITextResourceAssemblies()
{
#if !NETSTANDARD1_6
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic).ToList();
List <string> loadedPaths = new List <string>();
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
var path = a.Location;
loadedPaths.Add(path);
}
catch
{
// to skip exceptions for dynamically loaded assemblies without location
// such as anonymously hosted dynamicmethods assembly for example
}
}
var referencedPaths = Directory.GetFiles(FileUtil.GetBaseDirectory(), "*.dll");
var toLoad = referencedPaths.Where(referencePath => !loadedPaths.Any(loadedPath => loadedPath.Equals(referencePath, StringComparison.OrdinalIgnoreCase))).ToList();
foreach (String path in toLoad)
{
try {
AssemblyName name = AssemblyName.GetAssemblyName(path);
if (iTextResourceAssemblyNames.Contains(name.Name) && !loadedAssemblies.Any(assembly => assembly.GetName().Name.Equals(name.Name)))
{
loadedAssemblies.Add(AppDomain.CurrentDomain.Load(name));
}
}
catch
{
}
}
#else
string runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
List <AssemblyName> loadedAssemblies = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).ToList();
var referencedPaths = Directory.GetFiles(FileUtil.GetBaseDirectory(), "*.dll");
foreach (String path in referencedPaths)
{
try
{
AssemblyName name = AssemblyLoadContext.GetAssemblyName(path);
if (iTextResourceAssemblyNames.Contains(name.Name) && !loadedAssemblies.Any(assembly => assembly.Name.Equals(name.Name)))
{
Assembly newAssembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
loadedAssemblies.Add(newAssembly.GetName());
}
}
catch
{
}
}
#endif
}
/// <remarks>
/// Assumes we have a lock on _guard.
/// </remarks>
private static Assembly LoadAndCache(AssemblyLoadContext context, string fullPath)
{
var assembly = context.LoadFromAssemblyPath(fullPath);
var name = AssemblyLoadContext.GetAssemblyName(fullPath).FullName;
s_pathsToAssemblies[fullPath] = assembly;
s_namesToAssemblies[name] = assembly;
return(assembly);
}
private static void LoadPlugins()
{
_pluginDirectory = ArkeCallFlowService.GetConfigValue("appSettings:PluginDirectory");
var assemblies =
from file in new DirectoryInfo(_pluginDirectory).GetFiles()
where file.Extension.ToLowerInvariant() == ".dll"
select Assembly.Load(AssemblyLoadContext.GetAssemblyName(file.FullName));
ObjectContainer.GetInstance().GetSimpleInjectorContainer().RegisterPackages(assemblies);
}
private static void LoadPlugins()
{
_pluginDirectory = ArkeCallFlowService.GetConfigValue("appSettings:PluginDirectory");
var assemblies =
from file in new DirectoryInfo(_pluginDirectory).GetFiles()
where string.Equals(file.Extension, ".dll", StringComparison.InvariantCultureIgnoreCase)
select Assembly.Load(AssemblyLoadContext.GetAssemblyName(file.FullName));
ObjectContainer.GetInstance().GetSimpleInjectorContainer().RegisterPackages(assemblies);
}
public static void LoadFromAssemblyName_ValidTrustedPlatformAssembly()
{
var asmName = AssemblyLoadContext.GetAssemblyName("System.Runtime.dll");
var loadContext = new CustomTPALoadContext();
// Usage of TPA and AssemblyLoadContext is mutually exclusive, you cannot use both.
// Since the premise is that you either want to use the default binding mechanism (via coreclr TPA binder)
// or supply your own (via AssemblyLoadContext) for your own assemblies.
Assert.Throws(typeof(FileLoadException),
() => loadContext.LoadFromAssemblyName(asmName));
}
protected override Assembly?Load(AssemblyName assemblyName)
{
if (WellKnownAssemblyNames.Contains(assemblyName.Name !))
{
// Force MSBuild assemblies to be loaded in the default ALC
// and unify to the current version.
return(null);
}
foreach (var cultureSubfolder in string.IsNullOrEmpty(assemblyName.CultureName)
// If no culture is specified, attempt to load directly from
// the known dependency paths.
? new[] { string.Empty }
// Search for satellite assemblies in culture subdirectories
// of the assembly search directories, but fall back to the
// bare search directory if that fails.
: new[] { assemblyName.CultureName, string.Empty })
{
foreach (var extension in Extensions)
{
var candidatePath = Path.Combine(_directory,
cultureSubfolder,
$"{assemblyName.Name}.{extension}");
if (!FileSystems.Default.FileExists(candidatePath))
{
continue;
}
AssemblyName candidateAssemblyName = AssemblyLoadContext.GetAssemblyName(candidatePath);
if (candidateAssemblyName.Version != assemblyName.Version)
{
continue;
}
return(LoadFromAssemblyPath(candidatePath));
}
}
// If the Assembly is provided via a file path, the following rules are used to load the assembly:
// - the assembly from the user specified path is loaded, if it exists, into the custom ALC, or
// - if the simple name of the assembly exists in the same folder as msbuild.exe, then that assembly gets loaded
// into the default ALC (so it's shared with other uses).
var assemblyNameInExecutableDirectory = Path.Combine(BuildEnvironmentHelper.Instance.CurrentMSBuildToolsDirectory,
assemblyName.Name);
if (FileSystems.Default.FileExists(assemblyNameInExecutableDirectory))
{
return(AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyNameInExecutableDirectory));
}
return(null);
}
/// <summary>
/// The populate cache for type and method symbols.
/// </summary>
/// <param name="binaryPath">
/// The binary path.
/// </param>
private void PopulateCacheForTypeAndMethodSymbols(string binaryPath)
{
try
{
var pdbFilePath = Path.ChangeExtension(binaryPath, ".pdb");
using (var pdbReader = new PortablePdbReader(new FileHelper().GetStream(pdbFilePath, FileMode.Open, FileAccess.Read)))
{
// At this point, the assembly should be already loaded into the load context. We query for a reference to
// find the types and cache the symbol information. Let the loader follow default lookup order instead of
// forcing load from a specific path.
#if NET46
var asm = Assembly.Load(AssemblyName.GetAssemblyName(binaryPath));
#else
var asm = Assembly.Load(AssemblyLoadContext.GetAssemblyName(binaryPath));
#endif
foreach (var type in asm.GetTypes())
{
// Get declared method infos
var methodInfoList = ((TypeInfo)type.GetTypeInfo()).DeclaredMethods;
var methodsNavigationData = new Dictionary <string, DiaNavigationData>();
foreach (var methodInfo in methodInfoList)
{
var diaNavigationData = pdbReader.GetDiaNavigationData(methodInfo);
if (diaNavigationData != null)
{
methodsNavigationData[methodInfo.Name] = diaNavigationData;
}
else
{
EqtTrace.Error(
string.Format(
"Unable to find source information for method: {0} type: {1}",
methodInfo.Name,
type.FullName));
}
}
if (methodsNavigationData.Count != 0)
{
this.methodsNavigationDataForType[type.FullName] = methodsNavigationData;
}
}
}
}
catch (Exception ex)
{
EqtTrace.Error("PortableSymbolReader: Failed to load symbols for binary: {0}", binaryPath);
EqtTrace.Error(ex);
this.Dispose();
throw;
}
}
/// <summary>
/// 从文件夹中获取所有的程序集
/// </summary>
/// <param name="folderPath"></param>
/// <param name="searchOption"></param>
public static List <Assembly> GetAllAssembliesInFolder(string folderPath, SearchOption searchOption)
{
var assemblyFiles = Directory
.EnumerateFiles(folderPath, "*.*", searchOption)
.Where(s => s.EndsWith(".dll") || s.EndsWith(".exe"));
#if CORE
return(assemblyFiles.Select(o => Assembly.Load(AssemblyLoadContext.GetAssemblyName(o))).ToList());
#else
return(assemblyFiles.Select(Assembly.LoadFile).ToList());
#endif
}