public static CompilationResult GetAssemblyFromCompilation(
IAssemblyLoadContext loader,
Compilation compilation)
{
EmitResult result;
using (var ms = new MemoryStream())
{
using (var pdb = new MemoryStream())
{
if (PlatformHelper.IsMono)
{
result = compilation.Emit(ms, pdbStream: null);
}
else
{
result = compilation.Emit(ms, pdbStream: pdb);
}
if (!result.Success)
{
var formatter = new DiagnosticFormatter();
var errorMessages = result.Diagnostics
.Where(IsError)
.Select(d => formatter.Format(d));
return CompilationResult.FromErrorMessages(errorMessages);
}
ms.Seek(0, SeekOrigin.Begin);
Assembly assembly;
if (PlatformHelper.IsMono)
{
assembly = loader.LoadStream(ms, assemblySymbols: null);
}
else
{
pdb.Seek(0, SeekOrigin.Begin);
assembly = loader.LoadStream(ms, pdb);
}
return CompilationResult.FromAssembly(assembly);
}
}
}
protected T InvokeProtectedMethodOnLoadContextAndGetResult <T>(IAssemblyLoadContext loadContext, string methodName, params object[] args)
{
return((T)loadContext
.GetType()
.GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(loadContext, args));
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IRuntimeEnvironment runtimeEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache) :
this(applicationEnvironment, runtimeEnvironment, defaultLoadContext, cache, NoopWatcher.Instance)
{
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IRuntimeEnvironment runtimeEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache)
: this(applicationEnvironment, runtimeEnvironment, defaultLoadContext, cache, NoopWatcher.Instance)
{
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache,
IProjectGraphProvider projectGraphProvider) :
this(applicationEnvironment, defaultLoadContext, cache, NoopWatcher.Instance, projectGraphProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="InProcDataCollector"/> class.
/// </summary>
/// <param name="codeBase">
/// </param>
/// <param name="assemblyQualifiedName">
/// </param>
/// <param name="interfaceTypeInfo">
/// </param>
/// <param name="configXml">
/// </param>
/// <param name="assemblyLoadContext">
/// </param>
internal InProcDataCollector(string codeBase, string assemblyQualifiedName, TypeInfo interfaceTypeInfo, string configXml, IAssemblyLoadContext assemblyLoadContext, TestPluginCache testPluginCache)
{
this.configXml = configXml;
this.assemblyLoadContext = assemblyLoadContext;
var assembly = this.LoadInProcDataCollectorExtension(codeBase);
Func <Type, bool> filterPredicate;
if (Path.GetFileName(codeBase) == Constants.CoverletDataCollectorCodebase)
{
// If we're loading coverlet collector we skip to check the version of assembly
// to allow upgrade throught nuget package
filterPredicate = (x) => x.FullName.Equals(Constants.CoverletDataCollectorTypeName) && interfaceTypeInfo.IsAssignableFrom(x.GetTypeInfo());
// Coverlet collector is consumed as nuget package we need to add assemblies directory to resolver to correctly load references.
Debug.Assert(Path.IsPathRooted(codeBase), "Absolute path expected");
testPluginCache.AddResolverSearchDirectories(new string[] { Path.GetDirectoryName(codeBase) });
}
else
{
filterPredicate = (x) => x.AssemblyQualifiedName.Equals(assemblyQualifiedName) && interfaceTypeInfo.IsAssignableFrom(x.GetTypeInfo());
}
this.dataCollectorType = assembly?.GetTypes().FirstOrDefault(filterPredicate);
this.AssemblyQualifiedName = this.dataCollectorType?.AssemblyQualifiedName;
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// An assembly name like "MyLibrary!alternate!more-text"
// is parsed into:
// name == "MyLibrary"
// aspect == "alternate"
// and the more-text may be used to force a recompilation of an aspect that would
// otherwise have been cached by some layer within Assembly.Load
var name = assemblyName.Name;
string aspect = null;
var parts = name.Split(new[] { '!' }, 3);
if (parts.Length != 1)
{
name = parts[0];
aspect = parts[1];
}
Project project;
if (!_projectResolver.TryResolveProject(name, out project))
{
return null;
}
return _compilationEngine.LoadProject(
project,
aspect,
loadContext);
}
public AssemblyLoadContextFactory(IServiceProvider serviceProvider)
{
var accessor = serviceProvider.GetService(typeof(IAssemblyLoadContextAccessor)) as IAssemblyLoadContextAccessor;
_serviceProvider = serviceProvider;
_defaultContext = accessor.Default;
}
private void PluginMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext)
{
IPlugin plugin;
if (_registeredPlugins.TryGetValue(message.PluginId, out plugin))
{
try
{
plugin.ProcessMessage(message.Data, assemblyLoadContext);
}
catch (Exception exception)
{
OnError(
message.PluginId,
PluginMessageMessageName,
errorMessage: Resources.FormatPlugin_EncounteredExceptionWhenProcessingPluginMessage(
message.PluginId,
exception.Message));
}
}
else
{
OnError(
message.PluginId,
PluginMessageMessageName,
errorMessage: Resources.FormatPlugin_UnregisteredPluginIdCannotReceiveMessages(message.PluginId));
}
}
public void ProcessMessages(IAssemblyLoadContext assemblyLoadContext)
{
if (assemblyLoadContext == null)
{
throw new ArgumentNullException(nameof(assemblyLoadContext));
}
while (_messageQueue.Count > 0)
{
var message = _messageQueue.Dequeue();
switch (message.MessageName)
{
case RegisterPluginMessageName:
RegisterMessage(message, assemblyLoadContext);
break;
case UnregisterPluginMessageName:
UnregisterMessage(message);
break;
case PluginMessageMessageName:
PluginMessage(message, assemblyLoadContext);
break;
default:
OnNoop(
message,
Resources.FormatPlugin_PluginHandlerCouldNotHandleMessage(
message.MessageName,
message.PluginId));
break;
}
}
}
public void TryRegisterFaultedPlugins(IAssemblyLoadContext assemblyLoadContext)
{
if (assemblyLoadContext == null)
{
throw new ArgumentNullException(nameof(assemblyLoadContext));
}
// Capture the messages here so we can clear the original list to potentially re-add messages if they
// fail to recover.
var faultedRegistrations = _faultedRegisterPluginMessages.ToArray();
_faultedRegisterPluginMessages.Clear();
foreach (var faultedRegisterPluginMessage in faultedRegistrations)
{
var response = RegisterPlugin(faultedRegisterPluginMessage, assemblyLoadContext);
if (response.Success)
{
SendMessage(faultedRegisterPluginMessage.PluginId, response);
}
else
{
// We were unable to recover, re-add the faulted register plugin message.
_faultedRegisterPluginMessages.Add(faultedRegisterPluginMessage);
}
}
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// An assembly name like "MyLibrary!alternate!more-text"
// is parsed into:
// name == "MyLibrary"
// aspect == "alternate"
// and the more-text may be used to force a recompilation of an aspect that would
// otherwise have been cached by some layer within Assembly.Load
var name = assemblyName.Name;
string aspect = null;
var parts = name.Split(new[] { '!' }, 3);
if (parts.Length != 1)
{
name = parts[0];
aspect = parts[1];
}
var library = _libraryManager.GetLibraryDescription(name) as ProjectDescription;
if (library == null)
{
return null;
}
return _compilationEngine.LoadProject(
library.Project,
aspect,
loadContext);
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// An assembly name like "MyLibrary!alternate!more-text"
// is parsed into:
// name == "MyLibrary"
// aspect == "alternate"
// and the more-text may be used to force a recompilation of an aspect that would
// otherwise have been cached by some layer within Assembly.Load
var name = assemblyName.Name;
string aspect = null;
var parts = name.Split(new[] { '!' }, 3);
if (parts.Length != 1)
{
name = parts[0];
aspect = parts[1];
}
Project project;
if (!_projectResolver.TryResolveProject(name, out project))
{
return(null);
}
return(_compilationEngine.LoadProject(
project,
aspect,
loadContext));
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache) :
this(applicationEnvironment, defaultLoadContext, cache, NoopWatcher.Instance, new ProjectGraphProvider())
{
}
public void ProcessMessages([NotNull] IAssemblyLoadContext assemblyLoadContext)
{
while (_messageQueue.Count > 0)
{
var message = _messageQueue.Dequeue();
switch (message.MessageName)
{
case RegisterPluginMessageName:
RegisterMessage(message, assemblyLoadContext);
break;
case UnregisterPluginMessageName:
UnregisterMessage(message);
break;
case PluginMessageMessageName:
PluginMessage(message, assemblyLoadContext);
break;
default:
OnNoop(
message,
Resources.FormatPlugin_PluginHandlerCouldNotHandleMessage(
message.MessageName,
message.PluginId));
break;
}
}
}
/// <summary>
/// Loads the assembly containing precompiled views.
/// </summary>
/// <param name="loadContext">The <see cref="IAssemblyLoadContext"/>.</param>
/// <returns>The <see cref="Assembly"/> containing precompiled views.</returns>
public virtual Assembly LoadAssembly(IAssemblyLoadContext loadContext)
{
var viewCollectionAssembly = GetType().GetTypeInfo().Assembly;
using (var assemblyStream = viewCollectionAssembly.GetManifestResourceStream(AssemblyResourceName))
{
if (assemblyStream == null)
{
var message = Resources.FormatRazorFileInfoCollection_ResourceCouldNotBeFound(AssemblyResourceName,
GetType().FullName);
throw new InvalidOperationException(message);
}
Stream symbolsStream = null;
if (!string.IsNullOrEmpty(SymbolsResourceName))
{
symbolsStream = viewCollectionAssembly.GetManifestResourceStream(SymbolsResourceName);
}
using (symbolsStream)
{
return loadContext.LoadStream(assemblyStream, symbolsStream);
}
}
}
private void PluginMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext)
{
IPlugin plugin;
if (_registeredPlugins.TryGetValue(message.PluginId, out plugin))
{
try
{
if (!plugin.ProcessMessage(message.Data, assemblyLoadContext))
{
// Plugin didn't handle the message. Notify the client that we no-oped so it can respond
// accordingly.
OnNoop(
message,
Resources.FormatPlugin_PluginCouldNotHandleMessage(message.PluginId, message.MessageName));
}
}
catch (Exception exception)
{
OnError(
message,
errorMessage: Resources.FormatPlugin_EncounteredExceptionWhenProcessingPluginMessage(
message.PluginId,
exception.Message));
}
}
else
{
OnError(
message,
errorMessage: Resources.FormatPlugin_UnregisteredPluginIdCannotReceiveMessages(message.PluginId));
}
}
public static IEnumerable <Assembly> GetAssemblies(string path, IAssemblyLoaderContainer assemblyLoaderContainer, IAssemblyLoadContextAccessor assemblyLoadContextAccessor, ILibraryManager libraryManager)
{
List <Assembly> assemblies = new List <Assembly>();
IAssemblyLoadContext assemblyLoadContext = assemblyLoadContextAccessor.Default;
using (assemblyLoaderContainer.AddLoader(new DirectoryAssemblyLoader(path, assemblyLoadContext)))
{
foreach (string extensionPath in Directory.EnumerateFiles(path, "*.dll"))
{
string extensionFilename = Path.GetFileNameWithoutExtension(extensionPath);
assemblies.Add(assemblyLoadContext.Load(extensionFilename));
}
}
// We must not load all of the assemblies
foreach (Library library in libraryManager.GetLibraries())
{
if (AssemblyManager.IsCandidateLibrary(libraryManager, library))
{
assemblies.AddRange(library.Assemblies.Select(an => assemblyLoadContext.Load(an)));
}
}
return(assemblies);
}
public LibraryExporter(LibraryManager manager, IAssemblyLoadContext loadContext, CompilationEngine compilationEngine, string configuration)
{
LibraryManager = manager;
_compilationEngine = compilationEngine;
_configuration = configuration;
_loadContext = loadContext;
}
/// <summary>
/// Loads the assembly containing precompiled views.
/// </summary>
/// <param name="loadContext">The <see cref="IAssemblyLoadContext"/>.</param>
/// <returns>The <see cref="Assembly"/> containing precompiled views.</returns>
public virtual Assembly LoadAssembly(IAssemblyLoadContext loadContext)
{
var viewCollectionAssembly = GetType().GetTypeInfo().Assembly;
using (var assemblyStream = viewCollectionAssembly.GetManifestResourceStream(AssemblyResourceName))
{
if (assemblyStream == null)
{
var message = Resources.FormatRazorFileInfoCollection_ResourceCouldNotBeFound(AssemblyResourceName,
GetType().FullName);
throw new InvalidOperationException(message);
}
Stream symbolsStream = null;
if (!string.IsNullOrEmpty(SymbolsResourceName))
{
symbolsStream = viewCollectionAssembly.GetManifestResourceStream(SymbolsResourceName);
}
using (symbolsStream)
{
return(loadContext.LoadStream(assemblyStream, symbolsStream));
}
}
}
public LibraryExporter(LibraryManager manager, IAssemblyLoadContext loadContext, CompilationEngine compilationEngine, string configuration)
{
LibraryManager = manager;
_compilationEngine = compilationEngine;
_configuration = configuration;
_loadContext = loadContext;
}
public void TryRegisterFaultedPlugins(IAssemblyLoadContext assemblyLoadContext)
{
if (assemblyLoadContext == null)
{
throw new ArgumentNullException(nameof(assemblyLoadContext));
}
// Capture the messages here so we can clear the original list to potentially re-add messages if they
// fail to recover.
var faultedRegistrations = _faultedRegisterPluginMessages.ToArray();
_faultedRegisterPluginMessages.Clear();
foreach (var faultedRegisterPluginMessage in faultedRegistrations)
{
var response = RegisterPlugin(faultedRegisterPluginMessage, assemblyLoadContext);
if (response.Success)
{
SendMessage(faultedRegisterPluginMessage.PluginId, response);
}
else
{
// We were unable to recover, re-add the faulted register plugin message.
_faultedRegisterPluginMessages.Add(faultedRegisterPluginMessage);
}
}
}
public static T CreateService <T>(IServiceProvider sp, IAssemblyLoadContext loadContext, TypeInformation typeInfo)
{
var assembly = loadContext.Load(typeInfo.AssemblyName);
var type = assembly.GetType(typeInfo.TypeName);
return((T)ActivatorUtilities.CreateInstance(sp, type));
}
public LibraryAssemblyLoadContext(ProjectAssemblyLoader projectAssemblyLoader,
NuGetAssemblyLoader nugetAssemblyLoader,
IAssemblyLoadContext defaultContext)
{
_projectAssemblyLoader = projectAssemblyLoader;
_nugetAssemblyLoader = nugetAssemblyLoader;
_defaultContext = defaultContext;
}
public RoslynCompilationService(IApplicationEnvironment environment,
IAssemblyLoadContextAccessor accessor,
ILibraryExporter libraryExporter)
{
_environment = environment;
_loader = accessor.GetLoadContext(typeof(RoslynCompilationService).GetTypeInfo().Assembly);
_libraryExporter = libraryExporter;
}
public RuntimeLoadContext(LibraryManager libraryManager,
ICompilationEngine compilationEngine,
IAssemblyLoadContext defaultContext)
{
_projectAssemblyLoader = new ProjectAssemblyLoader(loadContextAccessor: null, compilationEngine: compilationEngine, libraryManager: libraryManager);
_packageAssemblyLoader = new PackageAssemblyLoader(loadContextAccessor: null, libraryManager: libraryManager);
_defaultContext = defaultContext;
}
public RuntimeLoadContext(LibraryManager libraryManager,
ICompilationEngine compilationEngine,
IAssemblyLoadContext defaultContext)
{
_projectAssemblyLoader = new ProjectAssemblyLoader(loadContextAccessor: null, compilationEngine: compilationEngine, libraryManager: libraryManager);
_packageAssemblyLoader = new PackageAssemblyLoader(loadContextAccessor: null, libraryManager: libraryManager);
_defaultContext = defaultContext;
}
public LibraryAssemblyLoadContext(ProjectAssemblyLoader projectAssemblyLoader,
NuGetAssemblyLoader nugetAssemblyLoader,
IAssemblyLoadContext defaultContext) : base(defaultContext)
{
_projectAssemblyLoader = projectAssemblyLoader;
_nugetAssemblyLoader = nugetAssemblyLoader;
_defaultContext = defaultContext;
}
public RoslynCompilationService(IApplicationEnvironment environment,
IAssemblyLoadContextAccessor accessor,
ILibraryExporter libraryExporter)
{
_environment = environment;
_loader = accessor.GetLoadContext(typeof(RoslynCompilationService).GetTypeInfo().Assembly);
_libraryExporter = libraryExporter;
}
/// <summary>
/// Test logger manager.
/// </summary>
/// <param name="requestData"></param>
/// <param name="messageLogger"></param>
/// <param name="loggerEvents"></param>
/// <param name="assemblyLoadContext"></param>
internal TestLoggerManager(IRequestData requestData, IMessageLogger messageLogger,
InternalTestLoggerEvents loggerEvents, IAssemblyLoadContext assemblyLoadContext)
{
this.requestData = requestData;
this.messageLogger = messageLogger;
this.testLoggerExtensionManager = null;
this.loggerEvents = loggerEvents;
this.assemblyLoadContext = assemblyLoadContext;
}
public AssemblyLoader(
IAssemblyDataProvider assemblyDataProvider,
IAssemblyLoadContext assemblyLoadContext)
{
_assemblyDataProvider = assemblyDataProvider;
_assemblyLoadContext = assemblyLoadContext;
_loadingAssemblies = new ConcurrentDictionary <AssemblyName, Task <Assembly?> >(
AssemblyByNameAndVersionComparer.Default);
}
public Assembly Load(string name, IAssemblyLoadContext loadContext)
{
PackageAssembly assemblyInfo;
if (_dependencyResolver.PackageAssemblyLookup.TryGetValue(name, out assemblyInfo))
{
return loadContext.LoadFile(assemblyInfo.Path);
}
return null;
}
public AssemblyCache(ILibraryManager manager,
IAssemblyLoadContextAccessor accessor,
IAssemblyLoaderContainer container,
IApplicationEnvironment environment)
{
_libraryManager = manager;
_environment = environment;
_loadContext = accessor.GetLoadContext(typeof (Program).GetTypeInfo().Assembly);
Loader = new DirectoryLookupAssemblyLoader(_loadContext);
_loaderRegistration = container.AddLoader(Loader);
}
public Assembly Load(string name, IAssemblyLoadContext loadContext)
{
PackageAssembly assemblyInfo;
if (_dependencyResolver.PackageAssemblyLookup.TryGetValue(name, out assemblyInfo))
{
return(loadContext.LoadFile(assemblyInfo.Path));
}
return(null);
}
/// <summary>
/// Initalizes a new instance of the <see cref="RoslynCompilationService"/> class.
/// </summary>
/// <param name="environment">The environment for the executing application.</param>
/// <param name="loaderEngine">The loader used to load compiled assemblies.</param>
/// <param name="libraryManager">The library manager that provides export and reference information.</param>
/// <param name="host">The <see cref="IMvcRazorHost"/> that was used to generate the code.</param>
public RoslynCompilationService(IApplicationEnvironment environment,
IAssemblyLoadContextAccessor loaderAccessor,
ILibraryManager libraryManager,
IMvcRazorHost host)
{
_environment = environment;
_loader = loaderAccessor.GetLoadContext(typeof(RoslynCompilationService).GetTypeInfo().Assembly);
_libraryManager = libraryManager;
_applicationReferences = new Lazy <List <MetadataReference> >(GetApplicationReferences);
_classPrefix = host.MainClassNamePrefix;
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// TODO: preserve name and culture info (we don't need to look at any other information)
string path;
if (_assemblies.TryGetValue(new AssemblyName(assemblyName.Name), out path))
{
return loadContext.LoadFile(path);
}
return null;
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// TODO: preserve name and culture info (we don't need to look at any other information)
PackageAssembly assemblyInfo;
if (_dependencyResolver.PackageAssemblyLookup.TryGetValue(new AssemblyName(assemblyName.Name), out assemblyInfo))
{
return loadContext.LoadFile(assemblyInfo.Path);
}
return null;
}
private void RegisterMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext)
{
var response = RegisterPlugin(message, assemblyLoadContext);
if (!response.Success)
{
_faultedRegisterPluginMessages.Add(message);
}
SendMessage(message.PluginId, response);
}
public Assembly Load(IAssemblyLoadContext loadContext)
{
using (var pdbStream = new MemoryStream())
using (var assemblyStream = new MemoryStream())
{
IList <ResourceDescription> resources = CompilationContext.Resources;
Trace.TraceInformation("[{0}]: Emitting assembly for {1}", GetType().Name, Name);
var sw = Stopwatch.StartNew();
EmitResult emitResult = null;
if (_supportsPdbGeneration.Value)
{
emitResult = CompilationContext.Compilation.Emit(assemblyStream, pdbStream: pdbStream, manifestResources: resources);
}
else
{
Trace.TraceWarning("PDB generation is not supported on this platform");
emitResult = CompilationContext.Compilation.Emit(assemblyStream, manifestResources: resources);
}
sw.Stop();
Trace.TraceInformation("[{0}]: Emitted {1} in {2}ms", GetType().Name, Name, sw.ElapsedMilliseconds);
var diagnostics = CompilationContext.Diagnostics.Concat(
emitResult.Diagnostics);
if (!emitResult.Success ||
diagnostics.Any(RoslynDiagnosticUtilities.IsError))
{
throw new RoslynCompilationException(diagnostics);
}
Assembly assembly = null;
// Rewind the stream
assemblyStream.Seek(0, SeekOrigin.Begin);
pdbStream.Seek(0, SeekOrigin.Begin);
if (pdbStream.Length == 0)
{
assembly = loadContext.LoadStream(assemblyStream, assemblySymbols: null);
}
else
{
assembly = loadContext.LoadStream(assemblyStream, pdbStream);
}
return(assembly);
}
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// TODO: preserve name and culture info (we don't need to look at any other information)
string path;
if (_assemblies.TryGetValue(new AssemblyName(assemblyName.Name), out path))
{
return(loadContext.LoadFile(path));
}
return(null);
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
// TODO: preserve name and culture info (we don't need to look at any other information)
PackageAssembly assemblyInfo;
if (_dependencyResolver.PackageAssemblyLookup.TryGetValue(new AssemblyName(assemblyName.Name), out assemblyInfo))
{
return(loadContext.LoadFile(assemblyInfo.Path));
}
return(null);
}
public static void Register(CommandLineApplication app, IAssemblyLoadContext assemblyLoadContext)
{
app.Command("resolve-taghelpers", config =>
{
config.Description = "Resolves TagHelperDescriptors in the specified assembly(s).";
config.HelpOption("-?|-h|--help");
var clientProtocol = config.Option(
"-p|--protocol",
"Provide client protocol version.",
CommandOptionType.SingleValue);
var assemblyNames = config.Argument(
"[name]",
"Assembly name to resolve TagHelperDescriptors in.",
multipleValues: true);
config.OnExecute(() =>
{
var messageBroker = new CommandMessageBroker();
var plugin = new RazorPlugin(messageBroker);
var resolvedProtocol = ResolveProtocolCommand.ResolveProtocol(clientProtocol, plugin.Protocol);
plugin.Protocol = resolvedProtocol;
var success = true;
foreach (var assemblyName in assemblyNames.Values)
{
var messageData = new ResolveTagHelperDescriptorsRequestData
{
AssemblyName = assemblyName,
SourceLocation = SourceLocation.Zero
};
var message = new RazorPluginRequestMessage(
RazorPluginMessageTypes.ResolveTagHelperDescriptors,
JObject.FromObject(messageData));
success &= plugin.ProcessMessage(JObject.FromObject(message), assemblyLoadContext);
}
var resolvedDescriptors = messageBroker.Results.SelectMany(result => result.Data.Descriptors);
var resolvedErrors = messageBroker.Results.SelectMany(result => result.Data.Errors);
var resolvedResult = new ResolvedTagHelperDescriptorsResult
{
Descriptors = resolvedDescriptors,
Errors = resolvedErrors
};
var serializedResult = JsonConvert.SerializeObject(resolvedResult, Formatting.Indented);
Console.WriteLine(serializedResult);
return success ? 0 : 1;
});
});
}
private static object GetCalculator()
{
IAssemblyLoadContext loadContext = PlatformServices.Default.AssemblyLoadContextAccessor.Default;
using (PlatformServices.Default.AssemblyLoaderContainer.AddLoader(new DirectoryLoader(CalculatorLibPath, loadContext)))
{
Assembly assembly = Assembly.Load(new AssemblyName(CalculatorLibName));
Type type = assembly.GetType(CalculatorTypeName);
return(Activator.CreateInstance(type));
}
}
public static void Register(CommandLineApplication app, IAssemblyLoadContext assemblyLoadContext)
{
app.Command("resolve-taghelpers", config =>
{
config.Description = "Resolves TagHelperDescriptors in the specified assembly(s).";
config.HelpOption("-?|-h|--help");
var clientProtocol = config.Option(
"-p|--protocol",
"Provide client protocol version.",
CommandOptionType.SingleValue);
var assemblyNames = config.Argument(
"[name]",
"Assembly name to resolve TagHelperDescriptors in.",
multipleValues: true);
config.OnExecute(() =>
{
var messageBroker = new CommandMessageBroker();
var plugin = new RazorPlugin(messageBroker);
var resolvedProtocol = ResolveProtocolCommand.ResolveProtocol(clientProtocol, plugin.Protocol);
plugin.Protocol = resolvedProtocol;
var success = true;
foreach (var assemblyName in assemblyNames.Values)
{
var messageData = new ResolveTagHelperDescriptorsRequestData
{
AssemblyName = assemblyName,
SourceLocation = SourceLocation.Zero
};
var message = new RazorPluginRequestMessage(
RazorPluginMessageTypes.ResolveTagHelperDescriptors,
JObject.FromObject(messageData));
success &= plugin.ProcessMessage(JObject.FromObject(message), assemblyLoadContext);
}
var resolvedDescriptors = messageBroker.Results.SelectMany(result => result.Data.Descriptors);
var resolvedErrors = messageBroker.Results.SelectMany(result => result.Data.Errors);
var resolvedResult = new ResolvedTagHelperDescriptorsResult
{
Descriptors = resolvedDescriptors,
Errors = resolvedErrors
};
var serializedResult = JsonConvert.SerializeObject(resolvedResult, Formatting.Indented);
Console.WriteLine(serializedResult);
return(success ? 0 : 1);
});
});
}
Assembly IMetadataProjectReference.Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
Console.WriteLine("*** PostSharpProjectReference.Load {0}.dll", _underlyingReference.Name);
string referencePath = Path.Combine(_workingDirectory, assemblyName.Name + ".dll");
if (File.Exists(referencePath))
{
return(loadContext.LoadFile(referencePath));
}
return(_underlyingReference.Load(assemblyName, loadContext));
}
/// <summary>
/// Initalizes a new instance of the <see cref="RoslynCompilationService"/> class.
/// </summary>
/// <param name="environment">The environment for the executing application.</param>
/// <param name="loaderEngine">The loader used to load compiled assemblies.</param>
/// <param name="libraryManager">The library manager that provides export and reference information.</param>
/// <param name="host">The <see cref="IMvcRazorHost"/> that was used to generate the code.</param>
public RoslynCompilationService(IApplicationEnvironment environment,
IAssemblyLoadContextAccessor loaderAccessor,
ILibraryManager libraryManager,
ICompilerOptionsProvider compilerOptionsProvider,
IMvcRazorHost host)
{
_environment = environment;
_loader = loaderAccessor.GetLoadContext(typeof(RoslynCompilationService).GetTypeInfo().Assembly);
_libraryManager = libraryManager;
_applicationReferences = new Lazy<List<MetadataReference>>(GetApplicationReferences);
_compilerOptionsProvider = compilerOptionsProvider;
_classPrefix = host.MainClassNamePrefix;
}
public IProjectCompiler GetCompiler(TypeInformation provider, IAssemblyLoadContext loadContext)
{
// TODO: Optimize the default compiler case by using the default load context directly
var services = new ServiceProvider(_context.Services);
services.Add(typeof(IAssemblyLoadContext), loadContext);
var assembly = loadContext.Load(provider.AssemblyName);
var type = assembly.GetType(provider.TypeName);
return (IProjectCompiler)ActivatorUtilities.CreateInstance(services, type);
}
/// <summary>
/// Initializes a new instance of the <see cref="InProcDataCollector"/> class.
/// </summary>
/// <param name="codeBase">
/// </param>
/// <param name="assemblyQualifiedName">
/// </param>
/// <param name="interfaceTypeInfo">
/// </param>
/// <param name="configXml">
/// </param>
/// <param name="assemblyLoadContext">
/// </param>
internal InProcDataCollector(string codeBase, string assemblyQualifiedName, TypeInfo interfaceTypeInfo, string configXml, IAssemblyLoadContext assemblyLoadContext)
{
this.configXml = configXml;
this.assemblyLoadContext = assemblyLoadContext;
var assembly = this.LoadInProcDataCollectorExtension(codeBase);
this.dataCollectorType =
assembly?.GetTypes()
.FirstOrDefault(x => x.AssemblyQualifiedName.Equals(assemblyQualifiedName) && interfaceTypeInfo.IsAssignableFrom(x.GetTypeInfo()));
this.AssemblyQualifiedName = this.dataCollectorType?.AssemblyQualifiedName;
}
/// <summary>
/// Initalizes a new instance of the <see cref="RoslynCompilationService"/> class.
/// </summary>
/// <param name="environment">The environment for the executing application.</param>
/// <param name="loaderAccessor">
/// The accessor for the <see cref="IAssemblyLoadContext"/> used to load compiled assemblies.
/// </param>
/// <param name="libraryExporter">The library manager that provides export and reference information.</param>
/// <param name="compilerOptionsProvider">
/// The <see cref="ICompilerOptionsProvider"/> that provides Roslyn compilation settings.
/// </param>
/// <param name="host">The <see cref="IMvcRazorHost"/> that was used to generate the code.</param>
public DefaultRoslynCompilationService(IApplicationEnvironment environment,
IAssemblyLoadContextAccessor loaderAccessor,
IOrchardLibraryManager libraryExporter,
ICompilerOptionsProvider compilerOptionsProvider,
IMvcRazorHost host,
IOptions<RazorViewEngineOptions> optionsAccessor)
{
_environment = environment;
_loader = loaderAccessor.GetLoadContext(typeof(DefaultRoslynCompilationService).GetTypeInfo().Assembly);
_libraryExporter = libraryExporter;
_applicationReferences = new Lazy<List<MetadataReference>>(GetApplicationReferences);
_compilerOptionsProvider = compilerOptionsProvider;
_fileProvider = optionsAccessor.Options.FileProvider;
_classPrefix = host.MainClassNamePrefix;
}
public RoslynCompiler(ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedDependencyProvider,
IAssemblyLoadContext loadContext,
IFileWatcher watcher,
IApplicationEnvironment environment,
IServiceProvider services)
{
_cache = cache;
_cacheContextAccessor = cacheContextAccessor;
_namedDependencyProvider = namedDependencyProvider;
_loadContext = loadContext;
_watcher = watcher;
_environment = environment;
_services = services;
}
public Assembly LoadProject(Project project, string aspect, IAssemblyLoadContext loadContext)
{
// Export the project
var export = ProjectExporter.ExportProject(project, this, aspect, _context.TargetFramework, _context.Configuration);
// Load the metadata reference
foreach (var projectReference in export.MetadataReferences.OfType<IMetadataProjectReference>())
{
if (string.Equals(projectReference.Name, project.Name, StringComparison.OrdinalIgnoreCase))
{
return projectReference.Load(loadContext);
}
}
return null;
}
public RuntimeLoadContext(string friendlyName,
IEnumerable<LibraryDescription> libraries,
ICompilationEngine compilationEngine,
IAssemblyLoadContext defaultContext) : base(friendlyName)
{
// TODO: Make this all lazy
// TODO: Unify this logic with default host
var projects = libraries.Where(p => p.Type == LibraryTypes.Project)
.OfType<ProjectDescription>();
var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries);
_projectAssemblyLoader = new ProjectAssemblyLoader(loadContextAccessor: null, compilationEngine: compilationEngine, projects: projects);
_packageAssemblyLoader = new PackageAssemblyLoader(loadContextAccessor: null, assemblies: assemblies, libraryDescriptions: libraries);
_defaultContext = defaultContext;
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IRuntimeEnvironment runtimeEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache)
{
ApplicationEnvironment = applicationEnvironment;
RuntimeEnvironment = runtimeEnvironment;
DefaultLoadContext = defaultLoadContext;
CompilationCache = cache;
// Register compiler services
AddCompilationService(typeof(IApplicationEnvironment), ApplicationEnvironment);
AddCompilationService(typeof(ICache), CompilationCache.Cache);
AddCompilationService(typeof(ICacheContextAccessor), CompilationCache.CacheContextAccessor);
AddCompilationService(typeof(INamedCacheDependencyProvider), CompilationCache.NamedCacheDependencyProvider);
}
public RoslynProjectCompiler(
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheProvider,
IAssemblyLoadContext loadContext,
IApplicationEnvironment environment,
IServiceProvider services)
{
_compiler = new RoslynCompiler(
cache,
cacheContextAccessor,
namedCacheProvider,
loadContext,
environment,
services);
}
public EntityFrameworkServices(
[NotNull]ILibraryManager libraryManager,
[NotNull]IApplicationEnvironment environment,
[NotNull]IAssemblyLoadContextAccessor loader,
[NotNull]IModelTypesLocator modelTypesLocator,
[NotNull]IDbContextEditorServices dbContextEditorServices,
[NotNull]IPackageInstaller packageInstaller,
[NotNull]ILogger logger)
{
_libraryManager = libraryManager;
_environment = environment;
_loader = loader.GetLoadContext(typeof(EntityFrameworkServices).GetTypeInfo().Assembly);
_modelTypesLocator = modelTypesLocator;
_dbContextEditorServices = dbContextEditorServices;
_packageInstaller = packageInstaller;
_logger = logger;
}
public Assembly LoadProject(Project project, string aspect, IAssemblyLoadContext loadContext)
{
var exporter = CreateProjectExporter(project, _context.ApplicationEnvironment.RuntimeFramework, _context.ApplicationEnvironment.Configuration);
// Export the project
var export = exporter.GetExport(project.Name, aspect);
// Load the metadata reference
foreach (var projectReference in export.MetadataReferences.OfType<IMetadataProjectReference>())
{
if (string.Equals(projectReference.Name, project.Name, StringComparison.OrdinalIgnoreCase))
{
return projectReference.Load(loadContext);
}
}
return null;
}
// Internal for unit testing
internal static Dictionary<string, Type> GetPrecompiledViews(
IEnumerable<RazorFileInfoCollection> razorFileInfoCollections,
IAssemblyLoadContext loadContext)
{
var precompiledViews = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
foreach (var viewCollection in razorFileInfoCollections)
{
var containingAssembly = viewCollection.LoadAssembly(loadContext);
foreach (var fileInfo in viewCollection.FileInfos)
{
var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
precompiledViews[fileInfo.RelativePath] = viewType;
}
}
return precompiledViews;
}
internal CompilerCache(IEnumerable<RazorFileInfoCollection> razorFileInfoCollections,
IAssemblyLoadContext loadContext,
IFileProvider fileProvider)
{
_fileProvider = fileProvider;
_cache = new MemoryCache(new MemoryCacheOptions { CompactOnMemoryPressure = false });
var cacheEntries = new List<CompilerCacheEntry>();
foreach (var viewCollection in razorFileInfoCollections)
{
var containingAssembly = viewCollection.LoadAssembly(loadContext);
foreach (var fileInfo in viewCollection.FileInfos)
{
var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
var cacheEntry = new CompilerCacheEntry(fileInfo, viewType);
// There shouldn't be any duplicates and if there are any the first will win.
// If the result doesn't match the one on disk its going to recompile anyways.
var normalizedPath = NormalizePath(fileInfo.RelativePath);
_cache.Set(
normalizedPath,
cacheEntry,
GetMemoryCacheEntryOptions(fileInfo.RelativePath));
cacheEntries.Add(cacheEntry);
}
}
// Set up _ViewImports
foreach (var entry in cacheEntries)
{
var globalFileLocations = ViewHierarchyUtility.GetViewImportsLocations(entry.RelativePath);
foreach (var location in globalFileLocations)
{
var globalFileEntry = _cache.Get<CompilerCacheEntry>(location);
if (globalFileEntry != null)
{
// Add the composite _ViewImports entry as a dependency.
entry.AssociatedGlobalFileEntry = globalFileEntry;
break;
}
}
}
}
public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
IAssemblyLoadContext defaultLoadContext,
CompilationCache cache,
IFileWatcher fileWatcher,
IProjectGraphProvider projectGraphProvider)
{
ApplicationEnvironment = applicationEnvironment;
DefaultLoadContext = defaultLoadContext;
ProjectGraphProvider = projectGraphProvider;
CompilationCache = cache;
FileWatcher = fileWatcher;
// Register compiler services
AddCompilationService(typeof(IFileWatcher), FileWatcher);
AddCompilationService(typeof(IApplicationEnvironment), ApplicationEnvironment);
AddCompilationService(typeof(ICache), CompilationCache.Cache);
AddCompilationService(typeof(ICacheContextAccessor), CompilationCache.CacheContextAccessor);
AddCompilationService(typeof(INamedCacheDependencyProvider), CompilationCache.NamedCacheDependencyProvider);
}
public Assembly Load(AssemblyName assemblyName, IAssemblyLoadContext loadContext)
{
if (_response.Diagnostics.HasErrors())
{
throw new DesignTimeCompilationException(_response.Diagnostics);
}
if (_response.AssemblyPath != null)
{
return loadContext.LoadFile(_response.AssemblyPath);
}
if (_response.PdbBytes == null)
{
return loadContext.LoadStream(new MemoryStream(_response.AssemblyBytes), assemblySymbols: null);
}
return loadContext.LoadStream(new MemoryStream(_response.AssemblyBytes),
new MemoryStream(_response.PdbBytes));
}
