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 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 LibraryExporter(LibraryManager manager, IAssemblyLoadContext loadContext, CompilationEngine compilationEngine, string configuration)
 {
     LibraryManager = manager;
     _compilationEngine = compilationEngine;
     _configuration = configuration;
     _loadContext = 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);
        }

        /// <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 CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
                                 IRuntimeEnvironment runtimeEnvironment,
                                 IAssemblyLoadContext defaultLoadContext,
                                 CompilationCache cache)
     : this(applicationEnvironment, runtimeEnvironment, defaultLoadContext, cache, NoopWatcher.Instance)
 {
 }

        public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
                                        IAssemblyLoadContext defaultLoadContext,
                                        CompilationCache cache) :
            this(applicationEnvironment, defaultLoadContext, cache, NoopWatcher.Instance, new ProjectGraphProvider())
        {

        }

 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 Assembly Load(string name, IAssemblyLoadContext loadContext)
        {
            PackageAssembly assemblyInfo;
            if (_dependencyResolver.PackageAssemblyLookup.TryGetValue(name, out assemblyInfo))
            {
                return loadContext.LoadFile(assemblyInfo.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 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 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 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;
                });
            });
        }

        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>
 /// 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;
 }

 /// <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 RoslynProjectCompiler(
     ICache cache,
     ICacheContextAccessor cacheContextAccessor,
     INamedCacheDependencyProvider namedCacheProvider,
     IAssemblyLoadContext loadContext,
     IApplicationEnvironment environment,
     IServiceProvider services)
 {
     _compiler = new RoslynCompiler(
         cache,
         cacheContextAccessor,
         namedCacheProvider,
         loadContext,
         environment,
         services);
 }

 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;
 }