private Assembly[] LoadReferencedAssemblies()
{
var assemblies = new List <Assembly>()
{
Assembly
};
#if DEBUG
_trace.WriteLine($"[NetCoreAssemblyRuntimeLoader][LoadReferencedAssemblies] Loading references for [{Assembly}]");
#endif
foreach (var assemblyName in Assembly.GetReferencedAssemblies())
{
try
{
#if DEBUG
_trace.WriteLine($"[NetCoreAssemblyRuntimeLoader][LoadReferencedAssemblies] Attempting to load [{assemblyName}]");
#endif
assemblies.Add(_loadContext.LoadFromAssemblyName(assemblyName));
}
catch (Exception ex)
{
// exception occurred, but we don't care
#if DEBUG
_trace.Error(ex, $"[NetCoreAssemblyRuntimeLoader][LoadReferencedAssemblies] Failed to load [{assemblyName}]");
#endif
}
}
return(assemblies.ToArray());
}
protected override Assembly?Load(AssemblyName assemblyName)
{
var simpleName = assemblyName.Name !;
if (_loader.AssemblySimpleNamesToBeLoadedInCompilerContext.Contains(simpleName))
{
// Delegate to the compiler's load context to load the compiler or anything
// referenced by the compiler
return(_compilerLoadContext.LoadFromAssemblyName(assemblyName));
}
var assemblyPath = Path.Combine(Directory, simpleName + ".dll");
var paths = _loader.GetPaths(simpleName);
if (paths is null)
{
// The analyzer didn't explicitly register this dependency. Most likely the
// assembly we're trying to load here is netstandard or a similar framework
// assembly. In this case, we want to load it in compiler's ALC to avoid any
// potential type mismatch issue. Otherwise, if this is truly an unknown assembly,
// we assume both compiler and default ALC will fail to load it.
return(_compilerLoadContext.LoadFromAssemblyName(assemblyName));
}
Debug.Assert(paths.Any());
// A matching assembly in this directory was specified via /analyzer.
if (paths.Contains(assemblyPath))
{
return(LoadFromAssemblyPath(_loader.GetPathToLoad(assemblyPath)));
}
AssemblyName?bestCandidateName = null;
string? bestCandidatePath = null;
// The assembly isn't expected to be found at 'assemblyPath',
// but some assembly with the same simple name is known to the loader.
foreach (var candidatePath in paths)
{
// Note: we assume that the assembly really can be found at 'candidatePath'
// (without 'GetPathToLoad'), and that calling GetAssemblyName doesn't cause us
// to hold a lock on the file. This prevents unnecessary shadow copies.
var candidateName = AssemblyName.GetAssemblyName(candidatePath);
// Checking FullName ensures that version and PublicKeyToken match exactly.
if (candidateName.FullName.Equals(assemblyName.FullName, StringComparison.OrdinalIgnoreCase))
{
return(LoadFromAssemblyPath(_loader.GetPathToLoad(candidatePath)));
}
else if (bestCandidateName is null || bestCandidateName.Version < candidateName.Version)
{
bestCandidateName = candidateName;
bestCandidatePath = candidatePath;
}
}
Debug.Assert(bestCandidateName != null);
Debug.Assert(bestCandidatePath != null);
return(LoadFromAssemblyPath(_loader.GetPathToLoad(bestCandidatePath)));
}
private static IReadOnlyList <MetadataReference> GetReferences(
AssemblyLoadContext assemblyLoadContext,
Assembly parentAssembly)
{
void PopulateTransitiveDependencies(Assembly assembly, ISet <AssemblyName> assemblyNames)
{
foreach (var referencedAssemblyName in assembly.GetReferencedAssemblies())
{
// Avoid doing the same work twice
if (!assemblyNames.Add(referencedAssemblyName))
{
continue;
}
var referencedAssembly = assemblyLoadContext.LoadFromAssemblyName(referencedAssemblyName);
PopulateTransitiveDependencies(referencedAssembly, assemblyNames);
}
}
IEnumerable <MetadataReference> EnumerateReferences()
{
// Implicit references
yield return(assemblyLoadContext
.LoadFromAssemblyName(new AssemblyName("Microsoft.CSharp"))
.ToMetadataReference());
yield return(assemblyLoadContext
.LoadFromAssemblyName(typeof(TemplateBase <>).Assembly.GetName())
.ToMetadataReference());
yield return(assemblyLoadContext
.LoadFromAssemblyName(parentAssembly.GetName())
.ToMetadataReference());
// References from parent assembly
var transitiveDependencies = new HashSet <AssemblyName>(AssemblyNameEqualityComparer.Instance);
PopulateTransitiveDependencies(parentAssembly, transitiveDependencies);
foreach (var dependency in transitiveDependencies)
{
yield return(assemblyLoadContext
.LoadFromAssemblyName(dependency)
.ToMetadataReference());
}
}
return(EnumerateReferences().Distinct().ToArray());
}
static Assembly LoadAssembly(String assemblyName, AssemblyLoadContext loadContext)
{
try
{
Logger.Log("Load assembly: " + assemblyName);
String executingAseemblyPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
//Assembly^ assembly = AssemblyLoadContext::GetLoadContext(Reflection::Assembly::GetExecutingAssembly())->LoadFromAssemblyPath(
// Path::Combine(executingAseemblyPath, (gcnew Reflection::AssemblyName(assemblyName))->Name + ".dll"));
AssemblyName actualAssemblyName = new AssemblyName(assemblyName);
Logger.Log("Actual assembly name is " + actualAssemblyName);
Assembly assembly = loadContext.LoadFromAssemblyName(actualAssemblyName);
//Assembly^ assembly = loadContext->LoadFromAssemblyPath(
// Path::Combine(executingAseemblyPath, (gcnew Reflection::AssemblyName(assemblyName))->Name + ".dll"));
return(assembly);
}
catch (System.Exception ex)
{
Logger.Log("Unable to load assembly: " + assemblyName + " with: " + ex.ToString());
}
return(null);
}
protected override Assembly Load(AssemblyName assemblyName)
{
if (assemblyName.Name == null)
{
return(null);
}
try
{
var defaultAssembly = _defaultLoadContext.LoadFromAssemblyName(assemblyName);
if (defaultAssembly != null)
{
return(defaultAssembly);
}
}
catch
{
}
var resolvedPath = _dependencyResolver.ResolveAssemblyToPath(assemblyName);
if (!string.IsNullOrEmpty(resolvedPath) && File.Exists(resolvedPath))
{
return(LoadFromAssemblyPath(resolvedPath));
}
var localFile = Path.Combine(_basePath, assemblyName.Name + ".dll");
if (File.Exists(localFile))
{
return(LoadFromAssemblyPath(localFile));
}
return(base.Load(assemblyName));
}
private static Type FindClassType(Guid clsid, string assemblyPath, string assemblyName, string typeName)
{
try
{
AssemblyLoadContext alc = GetALC(assemblyPath);
var assemblyNameLocal = new AssemblyName(assemblyName);
Assembly assem = alc.LoadFromAssemblyName(assemblyNameLocal);
Type t = assem.GetType(typeName);
if (t != null)
{
return(t);
}
}
catch (Exception e)
{
if (IsLoggingEnabled())
{
Log($"COM Activation of {clsid} failed. {e}");
}
}
const int CLASS_E_CLASSNOTAVAILABLE = unchecked ((int)0x80040111);
throw new COMException(string.Empty, CLASS_E_CLASSNOTAVAILABLE);
}
public void InitializeIsolation(bool isolated)
{
if (isolated == false)
{
alc = new AssemblyLoadContext("Isolated", isCollectible: true);
defaultAssembly = Assembly.GetExecutingAssembly();
alcAssembly = alc.LoadFromAssemblyPath(defaultAssembly.Location);
Assert.AreEqual(alcAssembly, alc.LoadFromAssemblyName(alcAssembly.GetName()));
alcProgramType = alcAssembly.GetType("ContextualReflectionTest.Program");
AssemblyLoadContext.Default.Resolving += TestResolve.ResolvingTestDefault;
alc.Resolving += TestResolve.ResolvingTestIsolated;
alcProgramInstance = (IProgram)Activator.CreateInstance(alcProgramType);
}
else
{
alcAssembly = Assembly.GetExecutingAssembly();
alc = AssemblyLoadContext.GetLoadContext(alcAssembly);
alcProgramType = typeof(Program);
alcProgramInstance = this;
defaultAssembly = AssemblyLoadContext.Default.LoadFromAssemblyName(alcAssembly.GetName());
}
}
public static IInputPlugin Load(IDependencyBuilder builder, InputConfiguration configuration, AssemblyLoadContext assemblyLoader)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(configuration.InputType))
{
throw new Exception("Can not instantiate a translation plugin without a plugin name.");
}
var assemblyName = $"{typeof(InputPluginLoader).Namespace}.{configuration.InputType}";
var assembly = assemblyLoader.LoadFromAssemblyName(new AssemblyName(assemblyName));
var type = assembly.GetExportedTypes().FirstOrDefault(x => typeof(IInputPlugin).GetTypeInfo().IsAssignableFrom(x));
if (type == null)
{
throw new Exception($"Can not find a class implementing '{nameof(IInputPlugin)}' in assembly '{assembly.FullName}'.");
}
var plugin = Activator.CreateInstance(type) as IInputPlugin;
if (plugin == null)
{
throw new Exception($"Couldn't instantiate '{type.Name}' plugin.");
}
plugin.RegisterPlugin(configuration, builder);
return(plugin);
}
private static Assembly Context_Resolving(AssemblyLoadContext context, AssemblyName assemblyName)
{
// avoid loading *.resources dlls, because of: https://github.com/dotnet/coreclr/issues/8416
if (assemblyName.Name.EndsWith("resources"))
{
return(null);
}
// check cached assemblies first
RuntimeLibrary library = DependencyContext.Default.RuntimeLibraries.FirstOrDefault(runtimeLibrary => runtimeLibrary.Name == assemblyName.Name);
if (library != null)
{
return(context.LoadFromAssemblyName(new AssemblyName(library.Name)));
}
// try known directories
string found = context.Assemblies.Select(x => Path.Combine(Path.GetDirectoryName(x.Location), $"{assemblyName.Name}.dll")).Distinct().FirstOrDefault(File.Exists);
if (found != null)
{
return(context.LoadFromAssemblyPath(found));
}
// try gac
found = Directory.GetFileSystemEntries(Environment.ExpandEnvironmentVariables("%windir%\\Microsoft.NET\\assembly"), $"{assemblyName.Name}.dll", SearchOption.AllDirectories).FirstOrDefault();
return(found == null ? null : context.LoadFromAssemblyPath(found));
}
public void SatelliteLoadsCorrectly(string alc, string assemblyName, string culture)
{
AssemblyName satelliteAssemblyName = new AssemblyName(assemblyName + ".resources");
satelliteAssemblyName.CultureInfo = new CultureInfo(culture);
AssemblyLoadContext assemblyLoadContext = contexts[alc];
Assembly satelliteAssembly = assemblyLoadContext.LoadFromAssemblyName(satelliteAssemblyName);
Assert.NotNull(satelliteAssembly);
AssemblyName parentAssemblyName = new AssemblyName(assemblyName);
Assembly parentAssembly = assemblyLoadContext.LoadFromAssemblyName(parentAssemblyName);
Assert.Equal(AssemblyLoadContext.GetLoadContext(parentAssembly), AssemblyLoadContext.GetLoadContext(satelliteAssembly));
}
private static Assembly OnAssemblyResolve(
AssemblyLoadContext assemblyLoadContext,
AssemblyName assemblyName)
{
try
{
AssemblyLoadContext.Default.Resolving -= OnAssemblyResolve;
return(assemblyLoadContext.LoadFromAssemblyName(assemblyName));
}
catch
{
// Intercept assembly load context failure
// Check to see if it's Dapper loading a DLL from .NET framework.
if (assemblyName.Name == MicrosoftSqlServerTypeAssembly)
{
return(typeof(SqlGeography).Assembly);
}
throw; // New other error
}
finally
{
AssemblyLoadContext.Default.Resolving += OnAssemblyResolve;
}
}
/// <summary>
/// The Load method override causes all the dependencies present in the plugin's binary directory to get loaded
/// into the HostAssemblyLoadContext together with the plugin assembly itself.
/// The Interface assembly must not be present in the plugin's binary directory, otherwise we would
/// end up with the assembly being loaded twice. Once in the default context and once in the HostAssemblyLoadContext.
/// </summary>
/// <param name="assemblyName">The assembly name to load.</param>
/// <returns></returns>
protected override Assembly Load(AssemblyName assemblyName)
{
if (null == assemblyName.Name)
{
return(null);
}
try
{
var assembly = _defaultLoadContext.LoadFromAssemblyName(assemblyName);
if (null != assembly)
{
return(assembly);
}
}
catch (Exception)
{
string assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
_traceService.Debug($"Resolving dependency: {assemblyName.Name}, v{assemblyName.Version} from componentAssemblyPath: {PluginPath}");
if (assemblyPath != null)
{
_traceService.Debug($"Resolved dependency. Loading {assemblyPath} into the PluginAssemblyLoadContext");
return(LoadFromAssemblyPath(assemblyPath));
}
else
{
_traceService.Debug($"Failed resolving dependency: {assemblyName.Name}, v{assemblyName.Version}");
}
}
return(null);
}
/// <summary>
/// Loads nng native library using specified load context and returns factory instance to create nng objects.
/// </summary>
/// <param name="loadContext">Load context into which native library is loaded</param>
/// <param name="factoryName">Name of factory type instance to create</param>
/// <returns></returns>
public static IAPIFactory <IMessage> Init(AssemblyLoadContext loadContext, string factoryName = "nng.Factories.Compat.Factory")
{
var assem = loadContext.LoadFromAssemblyName(new AssemblyName(managedAssemblyName));
var type = assem.GetType(factoryName);
return((IAPIFactory <IMessage>)Activator.CreateInstance(type));
}
private static Assembly AssemblyLoadContext_Resolving(AssemblyLoadContext context, AssemblyName assemblyName)
{
_logger.Info($"Resolving: {assemblyName.FullName}");
var assembly = context.LoadFromAssemblyName(assemblyName);
return(assembly);
}
protected override Assembly?Load(AssemblyName assemblyName)
{
if (assemblyName.Name == null)
{
return(null);
}
if (_sharedAssemblies.Contains(assemblyName.Name))
{
return(_mainLoadContext.LoadFromAssemblyName(assemblyName));
}
string?assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
if (assemblyPath != null)
{
AssemblyLoadedPath = assemblyPath;
// Load in memory to prevent locking the file
using var assemblyFile = File.Open(assemblyPath, FileMode.Open, FileAccess.Read, FileShare.Read);
string pdbPath = Path.ChangeExtension(assemblyPath, ".pdb");
if (File.Exists(pdbPath))
{
using var pdbFile = File.Open(pdbPath, FileMode.Open, FileAccess.Read, FileShare.Read);
return(LoadFromStream(assemblyFile, pdbFile));
}
return(LoadFromStream(assemblyFile));
}
return(null);
}
/// <summary>
/// Loads nng native library using specified load context and returns factory instance to create nng objects.
/// </summary>
/// <param name="loadContext">Load context into which native library is loaded</param>
/// <returns></returns>
public static IAPIFactory <IMessage> Init(AssemblyLoadContext loadContext)
{
var assem = loadContext.LoadFromAssemblyName(new System.Reflection.AssemblyName(managedAssemblyName));
var type = assem.GetType("nng.Tests.TestFactory");
return((IAPIFactory <IMessage>)Activator.CreateInstance(type));
}
private static Type GetTypeFromContext(AssemblyLoadContext ctx)
{
var asm = ctx.LoadFromAssemblyName(new AssemblyName(_assemblyName1));
var type = asm.GetType(_typeName);
return(type);
}
public BundleBuilderProxy(AssemblyLoadContext assemblyLoadContext, IReporter reporter)
{
if (assemblyLoadContext == null)
{
throw new ArgumentNullException(nameof(assemblyLoadContext));
}
if (reporter == null)
{
throw new ArgumentNullException(nameof(reporter));
}
_assemblyLoadContext = assemblyLoadContext;
_reporter = reporter;
Assembly bundlingAssembly;
try { bundlingAssembly = assemblyLoadContext.LoadFromAssemblyName(new AssemblyName(BundlingAssemblyName)); }
catch (Exception ex) { throw new InvalidOperationException($"Failed to load the {BundlingAssemblyName} assembly.", ex); }
Type bundleBuilderClass;
if ((_bundlingConfigurationType = bundlingAssembly.GetType("Karambolo.AspNetCore.Bundling.DesignTimeBundlingConfiguration", throwOnError: false, ignoreCase: false)) == null ||
(_configFileConfigurationType = bundlingAssembly.GetType("Karambolo.AspNetCore.Bundling.Internal.DesignTime.ConfigFileConfiguration", throwOnError: false, ignoreCase: false)) == null ||
(bundleBuilderClass = bundlingAssembly.GetType("Karambolo.AspNetCore.Bundling.Internal.DesignTime.BundleBuilder", throwOnError: false, ignoreCase: false)) == null ||
(_processMethodDefinition = bundleBuilderClass.GetMethod("ProcessAsync",
BindingFlags.Static | BindingFlags.Public,
null,
new[] { typeof(Dictionary <string, object>), typeof(CancellationToken) },
null)) == null)
{
throw new NotSupportedException($"The version of {BundlingAssemblyName} referenced by the application does not support design-time bundling. Please update the bundling library's NuGet packages and CLI tools to the latest version.");
}
}
private WeakReference LoadIntoALCAndUnload(string alcName, string assemblyName)
{
AssemblyLoadContext ctx = new AssemblyLoadContext(nameof(LoadAppAssemblyAndUnload), isCollectible: true);
Assembly asm = ctx.LoadFromAssemblyName(new AssemblyName("FeatureTest"));
ctx.Unload();
return(new WeakReference(ctx));
}
/// <summary>
/// Loads the Market Api interop.
/// </summary>
/// <param name="loadContext">Load context into which native library is loaded</param>
/// <returns></returns>
internal static IMarketApiInterop Init(AssemblyLoadContext loadContext)
{
var assem = loadContext.LoadFromAssemblyName(new System.Reflection.AssemblyName(managedAssemblyName));
var type = assem.GetType("GolemMarketApiMockup.GolemMarketApiInterop");
var instance = Activator.CreateInstance(type);
return((IMarketApiInterop)instance);
}
protected override IEnumerable <TypeInfo> GetExportedTypes(AssemblyName assemblyName)
{
var assembly = _loadContext.LoadFromAssemblyName(assemblyName);
var exportedTypes = assembly.ExportedTypes;
var exportedTypeInfos = exportedTypes.Select(type => type.GetTypeInfo());
return(exportedTypeInfos);
}
private static IReadOnlyList <Assembly> LoadAssemblyFromName(
AssemblyLoadContext loadContext,
AssemblyName assemblyName,
IEnumerable <string> dependencyDirectories,
Core.ILogger logger = null)
{
// If assembly exists in any of the dependency paths then load it from there.
var dependencyPath = dependencyDirectories.
Select(d =>
{
try
{
return
(Directory.EnumerateFiles(d, $"{assemblyName.Name}.dll", SearchOption.AllDirectories).
FirstOrDefault());
}
catch (Exception)
{
return(null);
}
}).
Where(p => p != null).
FirstOrDefault();
if (!string.IsNullOrEmpty(dependencyPath))
{
return(LoadAssemblyFromPath(loadContext, dependencyPath, dependencyDirectories, logger));
}
// Otherwise load by name from the context.
var output = new List <Assembly>();
try
{
output.Add(loadContext.LoadFromAssemblyName(assemblyName));
logger?.LogTrace($"Loaded assembly: '{output[0].FullName}'");
}
catch (Exception e)
{
if (logger != null)
{
logger?.LogWarning($"Failed to load assembly: {e.Message.ToDistinctLines()}");
}
return(Array.Empty <Assembly>());
}
// Load referenced assemblies.
foreach (var referencedAssemblyName in output[0].GetReferencedAssemblies())
{
if (!IsAssemblyLoaded(referencedAssemblyName))
{
output.AddRange(
LoadAssemblyFromName(loadContext, referencedAssemblyName, dependencyDirectories, logger));
}
}
return(output);
}
/// <summary>
/// Creates the link between the client and the server, while also passing in all the information to the server for setup
/// </summary>
/// <param name="alc">The target AssemblyLoadContext</param>
/// <param name="typeName">Name of the proxied type</param>
/// <param name="assemblyName">path of the assembly to the type</param>
/// <param name="genericTypes">any generics that we need the proxy to work with</param>
/// <exception cref="ArgumentNullException">Throws if we're missing either the given ALC, the AssemblyName to load, or the type to load from the assembly</exception>
public void SetUpServer(AssemblyLoadContext alc, string typeName, AssemblyName assemblyName, object[] constructorParams, Type[] genericTypes)
{
if (alc == null || typeName == null || assemblyName == null)
{
throw new ArgumentNullException();
}
if (genericTypes == null)
{
genericTypes = new Type[] { }
}
;
if (constructorParams == null)
{
constructorParams = new object[] { }
}
;
Assembly a = alc.LoadFromAssemblyName(assemblyName);
// Find the type we're going to proxy inside the loaded assembly
Type objType = FindTypeInAssembly(typeName, a);
// Get the interface of the object so we can set it as the server's generic type
Type interfaceType = FindInterfaceType(_intType.Name, objType);
if (interfaceType.IsGenericType)
{
interfaceType = interfaceType.MakeGenericType(genericTypes.Select(x => ConvertType(x, alc)).ToArray());
}
// Load *this* (ALCProxy.Communication) assembly into the ALC so we can get the server into the ALC
Assembly serverAssembly = alc.LoadFromAssemblyName(Assembly.GetAssembly(_serverType).GetName());
// Get the server type, then make it generic with the interface we're using
Type serverType = FindTypeInAssembly(_serverTypeName, serverAssembly).MakeGenericType(interfaceType);
// Give the client its reference to the server
SerializeParameters(constructorParams, out IList <object> serializedConstArgs, out IList <Type> argTypes);
ConstructorInfo ci = serverType.GetConstructor(
new Type[] { typeof(Type), typeof(Type[]), typeof(IList <object>), typeof(IList <Type>) });
_server = ci.Invoke(new object[] { objType, genericTypes, serializedConstArgs.ToList(), argTypes });
_serverDelegate = (ServerCall)Delegate.CreateDelegate(typeof(ServerCall), _server, serverType.GetMethod("CallObject"));
// Attach to the unloading event
alc.Unloading += UnloadClient;
}
public static Assembly?TryLoadFromAssemblyName(this AssemblyLoadContext loadContext, AssemblyName name)
{
try
{
return(loadContext.LoadFromAssemblyName(name));
}
catch
{
return(null);
}
}
private Assembly TryGetWellKnownAssembly(AssemblyLoadContext context, AssemblyName assemblyName)
{
if (!_wellKnownAssemblyNames.Contains(assemblyName.Name))
{
return(null);
}
assemblyName.Version = _currentAssemblyVersion;
return(context.LoadFromAssemblyName(assemblyName));
}
private static bool TryLoadAssembly(AssemblyLoadContext context, AssemblyName name, [NotNullWhen(true)] out Assembly?assembly)
{
try {
assembly = context.LoadFromAssemblyName(name);
return(true);
}
catch (FileNotFoundException) {
Console.WriteLine($"[WARN] Could not find assembly '{name.FullName}'.");
assembly = null;
return(false);
}
}
internal static Assembly?TryResolveAssemblyFromPaths(AssemblyLoadContext context, AssemblyName assemblyName, string searchPath, Dictionary <string, Assembly>?knownAssemblyPaths = null, ILogger?logger = null)
{
logger?.LogTrace($"Trying to resolve assembly {assemblyName.FullName}.");
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 = knownAssemblyPaths?.ContainsKey(candidatePath) == true;
if (isAssemblyLoaded || !File.Exists(candidatePath))
{
continue;
}
var candidateAssemblyName = AssemblyLoadContext.GetAssemblyName(candidatePath);
if (candidateAssemblyName.Version < assemblyName.Version)
{
continue;
}
try
{
var assembly = context.LoadFromAssemblyPath(candidatePath);
logger?.LogTrace($"Loaded assembly from {candidatePath}.");
return(assembly);
}
catch
{
if (assemblyName.Name != null)
{
// We were unable to load the assembly from the file path. It is likely that
// a different version of the assembly has already been loaded into the context.
// Be forgiving and attempt to load assembly by name without specifying a version.
return(context.LoadFromAssemblyName(new AssemblyName(assemblyName.Name)));
}
}
}
}
return(null);
}
public override Assembly Load(AssemblyName assemblyName)
{
try
{
return(AssemblyContext.LoadFromAssemblyName(assemblyName));
}
catch (Exception e)
{
_logger.LogError("名称加载程序集错误，原因：{1}", e);
return(null);
}
}
private static Assembly LoadAssembly(string assemblyName, AssemblyLoadContext ctx)
{
if (LoadedAssemblies.ContainsKey(assemblyName))
{
return(LoadedAssemblies[assemblyName]);
}
var assembly = ctx.LoadFromAssemblyName(new AssemblyName(PrivateAssemblies[assemblyName]));
LoadedAssemblies.Add(assemblyName, assembly);
return(assembly);
}
protected override Assembly Load(AssemblyName assemblyName)
{
// Try to load from well-known paths. This will be called when loading a dependency of an extension.
var assembly = _loader.Load(assemblyName.ToString());
if (assembly != null)
{
return(assembly);
}
// If we don't have an entry, then fall back to the default load context. This allows extensions
// to resolve assemblies that are provided by the host.
return(_parent.LoadFromAssemblyName(assemblyName));
}