internal Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
FunctionAssemblyLoadContext context = GetFunctionContext(args.RequestingAssembly);
Assembly result = null;
if (context != null)
{
result = context.ResolveAssembly(args.Name);
}
// If we were unable to resolve the assembly, apply the current App Domain policy and attempt to load it.
// This allows us to correctly handle retargetable assemblies, redirects, etc.
if (result == null)
{
string assemblyName = ((AppDomain)sender).ApplyPolicy(args.Name);
// If after applying the current policy, we now have a different target assembly name, attempt to load that
// assembly
if (string.Compare(assemblyName, args.Name) != 0)
{
result = Assembly.Load(assemblyName);
}
}
// If we have an function context and failed to resolve a function assembly dependency,
// log the failure as this is usually caused by missing private assemblies.
if (context != null && result == null)
{
context.TraceWriter.Warning(string.Format(CultureInfo.InvariantCulture,
"Unable to find assembly '{0}'. Are you missing a private assembly file?", args.Name));
}
return(result);
}
public FunctionAssemblyLoadContext CreateOrUpdateContext(FunctionMetadata metadata, Assembly functionAssembly, IFunctionMetadataResolver metadataResolver,
TraceWriter traceWriter, ILoggerFactory loggerFactory)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (functionAssembly == null)
{
throw new ArgumentNullException("functionAssembly");
}
if (metadataResolver == null)
{
throw new ArgumentNullException("metadataResolver");
}
if (traceWriter == null)
{
throw new ArgumentNullException("traceWriter");
}
ILogger logger = loggerFactory?.CreateLogger(LogCategories.Startup);
var context = new FunctionAssemblyLoadContext(metadata, functionAssembly, metadataResolver, traceWriter, logger);
return(_functionContexts.AddOrUpdate(metadata.Name, context, (s, o) => context));
}
private FunctionAssemblyLoadContext GetFunctionContext(Assembly requestingAssembly)
{
if (requestingAssembly == null)
{
return(null);
}
FunctionAssemblyLoadContext context = null;
string functionName = GetFunctionNameFromAssembly(requestingAssembly);
if (functionName != null)
{
context = GetFunctionContext(functionName);
// If the context is for a different assembly
if (context != null && context.FunctionAssembly != requestingAssembly)
{
return(null);
}
}
else
{
context = GetFunctionContextFromDependency(requestingAssembly);
}
return(context);
}
private static FunctionAssemblyLoadContext CreateSharedContext()
{
var sharedContext = new FunctionAssemblyLoadContext(ResolveFunctionBaseProbingPath());
Default.Resolving += HandleDefaultContextFallback;
return(sharedContext);
}
private Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
FunctionAssemblyLoadContext context = GetFunctionContext(args.RequestingAssembly);
Assembly result = null;
if (context != null)
{
result = context.ResolveAssembly(args.Name);
}
return(result);
}
internal Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
FunctionAssemblyLoadContext context = GetFunctionContext(args.RequestingAssembly);
Assembly result = null;
if (context != null)
{
result = context.ResolveAssembly(args.Name);
// Failed to resolve a function assembly dependency, log the failure as this
// is usually caused by missing private assemblies.
if (result == null)
{
context.TraceWriter.Warning(string.Format(CultureInfo.InvariantCulture, "Unable to find assembly '{0}'. Are you missing a private assembly file?", args.Name));
}
}
return(result);
}
public FunctionAssemblyLoadContext CreateOrUpdateContext(FunctionMetadata metadata, Assembly functionAssembly, FunctionMetadataResolver metadataResolver)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (functionAssembly == null)
{
throw new ArgumentNullException("functionAssembly");
}
if (metadataResolver == null)
{
throw new ArgumentNullException("metadataResolver");
}
var context = new FunctionAssemblyLoadContext(metadata, functionAssembly, metadataResolver);
return(_functionContexts.AddOrUpdate(metadata.Name, context, (s, o) => context));
}
public Assembly ResolveAssembly(AssemblyName assemblyName, FunctionAssemblyLoadContext targetContext)
{
Assembly assembly = null;
if (_externalReferences.TryGetValue(assemblyName.FullName, out string assemblyPath))
{
// For external references, we load the assemblies into the shared context:
assembly = FunctionAssemblyLoadContext.Shared.LoadFromAssemblyPath(assemblyPath, true);
}
else if (TryResolvePrivateAssembly(assemblyName.FullName, out assemblyPath))
{
assembly = targetContext.LoadFromStream(new MemoryStream(File.ReadAllBytes(assemblyPath)));
}
else if (_packageAssemblyResolver.TryResolveAssembly(assemblyName.FullName, out assemblyPath))
{
assembly = targetContext.LoadFromAssemblyPath(assemblyPath);
}
else
{
_extensionSharedAssemblyProvider.TryResolveAssembly(assemblyName.FullName, FunctionAssemblyLoadContext.Shared, _logger, out assembly);
}
return(assembly);
}
public Assembly ResolveAssembly(AssemblyName assemblyName, FunctionAssemblyLoadContext targetContext)
{
return(null);
}
public FunctionAssemblyLoadContext CreateOrUpdateContext(FunctionMetadata metadata, Assembly functionAssembly, IFunctionMetadataResolver metadataResolver, TraceWriter traceWriter)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (functionAssembly == null)
{
throw new ArgumentNullException("functionAssembly");
}
if (metadataResolver == null)
{
throw new ArgumentNullException("metadataResolver");
}
if (traceWriter == null)
{
throw new ArgumentNullException("traceWriter");
}
var context = new FunctionAssemblyLoadContext(metadata, functionAssembly, metadataResolver, traceWriter);
return _functionContexts.AddOrUpdate(metadata.Name, context, (s, o) => context);
}
