private bool SearchForLibrary(ManagedLibrary library, out string path)
{
// 1. Search in base path
foreach (var ext in s_managedAssemblyExtensions)
{
var local = Path.Combine(_basePath, library.Name.Name + ext);
if (File.Exists(local))
{
path = local;
return(true);
}
}
// 2. Search additional probing paths
foreach (var searchPath in _additionalProbingPaths)
{
var candidate = Path.Combine(searchPath, library.AdditionalProbingPath);
if (File.Exists(candidate))
{
path = candidate;
return(true);
}
}
path = null;
return(false);
}
/// <summary>
/// Add a managed library to the load context.
/// </summary>
/// <param name="library">The managed library.</param>
/// <returns>The builder.</returns>
public AssemblyLoadContextBuilder AddManagedLibrary(ManagedLibrary library)
{
ValidateRelativePath(library.AdditionalProbingPath);
_managedLibraries.Add(library.Name.Name, library);
return(this);
}
private static IEnumerable <ManagedLibrary> ResolveRuntimeAssemblies(this DependencyContext depContext, RuntimeFallbacks runtimeGraph)
{
var rids = GetRids(runtimeGraph);
return(from library in depContext.RuntimeLibraries
from assetPath in SelectAssets(rids, library.RuntimeAssemblyGroups)
select ManagedLibrary.CreateFromPackage(library.Name, library.Version, assetPath));
}
private static void EnsureExecutor()
{
if (_executor == null)
{
ManagedLibrary implementation = new ManagedLibrary();
implementation.AssemblyFile = Path.Join((string)Script.Literal("__dirname"), "SqlEdge.dll");
implementation.TypeName = "SimpleCloud.SqlEdge.SqlExecutor";
implementation.MethodName = "ExecuteSql";
_executor = Edge.BindToLibrary(implementation);
}
}
private bool SearchForLibrary(ManagedLibrary library, out string path)
{
// 1. Check for in _basePath + app local path
var basePaths = new List <string>();
if (!string.IsNullOrEmpty(this._sharedBasePath))
{
basePaths.Add(this._sharedBasePath);
}
basePaths.Add(this._basePath);
foreach (var basePath in basePaths)
{
var localFile = Path.Combine(basePath, library.AppLocalPath);
if (File.Exists(localFile))
{
if (basePath == this._sharedBasePath)
{
Logger.Trace(m => m("Будет загружен библиотека из файла [{0}].", localFile));
}
path = localFile;
return(true);
}
}
// 2. Search additional probing paths
foreach (var searchPath in _additionalProbingPaths)
{
var candidate = Path.Combine(searchPath, library.AdditionalProbingPath);
if (File.Exists(candidate))
{
path = candidate;
return(true);
}
}
// 3. Search in base path
foreach (var ext in PlatformInformation.ManagedAssemblyExtensions)
{
var local = Path.Combine(_basePath, library.Name.Name + ext);
if (File.Exists(local))
{
path = local;
return(true);
}
}
path = null;
return(false);
}
static Native()
{
ManagedLibrary.CheckRedistPackages();
ManagedLibrary.MarkAsReadOnly();
ManagedLibrary.ModulesManager.Extract();
if (ManagedLibrary.ResolveDotNetAssemblies)
{
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += OnAssemblyResolve;
AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
}
Construct();
}
/// <summary>
/// Loads assembly to AssemblyLoadContext.Default or gets it from own assembly cache.
/// <para>
/// Note that only one version of assembly would be loaded and cached by AssemblyName.Name, for all other versions returns cached assembly.
/// </para>
/// </summary>
/// <param name="managedLibrary">ManagedLibrary object containing library name and paths.</param>
/// <param name="loadContext">ManagedAssemblyLoadContext object.</param>
/// <returns>Retures loaded assembly (could be cached).</returns>
private Assembly LoadAssemblyCached(ManagedLibrary managedLibrary, ManagedAssemblyLoadContext loadContext)
{
var assemblyName = managedLibrary.Name;
if (_loadedAssemblies.ContainsKey(assemblyName.Name))
{
return(_loadedAssemblies[assemblyName.Name]);
}
var loadedAssembly = LoadAssemblyInternal(managedLibrary, loadContext);
if (loadedAssembly != null)
{
_loadedAssemblies.Add(assemblyName.Name, loadedAssembly);
}
return(loadedAssembly);
}
public static void AddCompileDependencies(this AssemblyLoadContextBuilder builder, DependencyContext dependencyContext)
{
foreach (var library in dependencyContext.CompileLibraries.Where(cl => !dependencyContext.RuntimeLibraries.Any(rl => cl.Name.Equals(rl.Name))))
{
foreach (var libraryAssembly in library.Assemblies.Where(a => a.StartsWith("lib", StringComparison.OrdinalIgnoreCase)))
{
var managedLibrary = ManagedLibrary.CreateFromPackage(library.Name, library.Version, libraryAssembly);
try
{
builder.AddManagedLibrary(managedLibrary);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
/// <summary>
/// Performs loading into AssemblyLoadContext.Default using LoadFromAssemblyName for TPA assemblies and LoadFromAssemblyPath for other dependecies.
/// <para>
/// Based on https://github.com/natemcmaster/DotNetCorePlugins/blob/8f5c28fa70f0869a1af2e2904536268f184e71de/src/Plugins/Loader/ManagedLoadContext.cs Load method,
/// but avoided FileNotFoundException from LoadFromAssemblyName trying only load TPA assemblies that way.
/// </para>
/// </summary>
/// <param name="managedLibrary">ManagedLibrary object containing assembly name and paths.</param>
/// <param name="loadContext">ManagedAssemblyLoadContext object.</param>
/// <returns>Returns loaded assembly.</returns>
private Assembly LoadAssemblyInternal(ManagedLibrary managedLibrary, ManagedAssemblyLoadContext loadContext)
{
// To avoid FileNotFoundException for assemblies that are included in TPA - we load them using AssemblyLoadContext.Default.LoadFromAssemblyName.
var assemblyFileName = Path.GetFileName(managedLibrary.AppLocalPath);
if (TPA.ContainsAssembly(assemblyFileName))
{
var defaultAssembly = AssemblyLoadContext.Default.LoadFromAssemblyName(managedLibrary.Name);
if (defaultAssembly != null)
{
return(defaultAssembly);
}
}
if (SearchForLibrary(managedLibrary, loadContext, out var path))
{
return(AssemblyLoadContext.Default.LoadFromAssemblyPath(path));
}
return(null);
}
private bool SearchForLibrary(ManagedLibrary library, out string path)
{
// 1. Search in base path
foreach (var ext in s_managedAssemblyExtensions)
{
var local = Path.Combine(_basePath, library.Name.Name + ext);
if (File.Exists(local))
{
path = local;
return true;
}
}
// 2. Search additional probing paths
foreach (var searchPath in _additionalProbingPaths)
{
var candidate = Path.Combine(searchPath, library.AdditionalProbingPath);
if (File.Exists(candidate))
{
path = candidate;
return true;
}
}
// 3. Search in _basePath/runtimes
if (library.AdditionalProbingPath.StartsWith(library.Name.Name, StringComparison.OrdinalIgnoreCase) &&
library.AdditionalProbingPath.Contains("runtimes"))
{
var postPackageSpecProbingPath = library.AdditionalProbingPath.Substring(library.AdditionalProbingPath.IndexOf("runtimes"));
var candidate = Path.Combine(_basePath, postPackageSpecProbingPath);
if (File.Exists(candidate))
{
path = candidate;
return true;
}
}
path = null;
return false;
}
private bool SearchForLibrary(ManagedLibrary library, ManagedAssemblyLoadContext loadContext, out string path)
{
// 1. Check for in _basePath + app local path
var localFile = Path.Combine(loadContext.BasePath, library.AppLocalPath);
if (File.Exists(localFile))
{
path = localFile;
return(true);
}
// 2. Search additional probing paths
foreach (var searchPath in loadContext.AdditionalProdingPath)
{
var candidate = Path.Combine(searchPath, library.AdditionalProbingPath);
if (File.Exists(candidate))
{
path = candidate;
return(true);
}
}
// 3. Search in base path
foreach (var ext in PlatformInformation.ManagedAssemblyExtensions)
{
var local = Path.Combine(loadContext.BasePath, library.Name.Name + ext);
if (File.Exists(local))
{
path = local;
return(true);
}
}
path = null;
return(false);
}
private Assembly ManagedLoadContext_Resolving(AssemblyLoadContext loadContext, AssemblyName assemblyName)
{
this.SearchForLibrary(ManagedLibrary.CreateFromPackage(assemblyName.Name, assemblyName.Version.ToString(), assemblyName.Name + ".dll"), out var path);
return(this.LoadFromAssemblyPath(path));
}
