public LibraryExporter(LibraryManager manager, CompilationEngine compilationEngine, FrameworkName targetFramework, string configuration)
{
_manager = manager;
_compilationEngine = compilationEngine;
_targetFramework = targetFramework;
_configuration = configuration;
}
public LibraryExporter(LibraryManager manager, IAssemblyLoadContext loadContext, CompilationEngine compilationEngine, string configuration)
{
LibraryManager = manager;
_compilationEngine = compilationEngine;
_configuration = configuration;
_loadContext = loadContext;
}
public BuildContext(CompilationEngine compilationEngine,
Runtime.Project project,
FrameworkName targetFramework,
string configuration,
string outputPath)
{
_project = project;
_targetFramework = targetFramework;
_configuration = configuration;
_targetFrameworkFolder = VersionUtility.GetShortFrameworkName(_targetFramework);
_outputPath = Path.Combine(outputPath, _targetFrameworkFolder);
_libraryExporter = compilationEngine.CreateProjectExporter(
_project, _targetFramework, _configuration);
_libraryManager = _libraryExporter.LibraryManager;
}
public LibraryExporter CreateProjectExporter(Project project, FrameworkName targetFramework, string configuration)
{
var graph = _context.ProjectGraphProvider.GetProjectGraph(project, targetFramework, configuration);
var manager = new LibraryManager(graph);
return new LibraryExporter(manager, this, targetFramework, configuration);
}
public DependencyListOperation(DependencyListOptions options, FrameworkName framework)
{
_options = options;
_framework = framework;
_libraryManager = CreateLibraryManager();
}
public LibraryExporter(LibraryManager manager, CompilationEngine compilationEngine, string configuration)
{
LibraryManager = manager;
_compilationEngine = compilationEngine;
_configuration = configuration;
}
public ApplicationHostContext(IServiceProvider hostServices,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework,
IAssemblyLoadContextFactory loadContextFactory = null,
bool skipLockFileValidation = false)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
ProjectGraphProvider = new ProjectGraphProvider(hostServices);
_serviceProvider = new ServiceProvider(hostServices);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(PackagesDirectory));
var gacDependencyResolver = new GacDependencyResolver();
ProjectDependencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectName = PathUtility.GetDirectoryName(ProjectDirectory);
Project project;
if (ProjectResolver.TryResolveProject(projectName, out project))
{
Project = project;
}
else
{
throw new InvalidOperationException(
string.Format("Unable to resolve project '{0}' from {1}", projectName, ProjectDirectory));
}
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
_lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = _lockFile.IsValidForProject(project);
// When the only invalid part of a lock file is version number,
// we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that
// VS can be aware of this version mismatch error and automatically do restore
skipLockFileValidation = skipLockFileValidation && (_lockFile.Version == Constants.LockFileVersion);
if (validLockFile || skipLockFileValidation)
{
NuGetDependencyProvider.ApplyLockFile(_lockFile);
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDependencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add NuGetDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
LibraryManager = new LibraryManager(() => DependencyWalker.Libraries);
AssemblyLoadContextFactory = loadContextFactory ?? new RuntimeLoadContextFactory(ServiceProvider);
// Create a new Application Environment for running the app. It needs a reference to the Host's application environment
// (if any), which we can get from the service provider we were given.
// If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating
// will just have it's own independent set of global data.
IApplicationEnvironment hostEnvironment = null;
if (hostServices != null)
{
hostEnvironment = (IApplicationEnvironment)hostServices.GetService(typeof(IApplicationEnvironment));
}
ApplicationEnvironment = new ApplicationEnvironment(Project, targetFramework, configuration, hostEnvironment);
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), ApplicationEnvironment);
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), new CompilerOptionsProvider(ProjectResolver));
// Not exposed to the application layer
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver, includeInManifest: false);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory, includeInManifest: false);
}
private void Initialize(RuntimeOptions options, IServiceProvider hostServices, IAssemblyLoadContextAccessor loadContextAccessor, IFileWatcher fileWatcher)
{
var applicationHostContext = new ApplicationHostContext
{
ProjectDirectory = _projectDirectory,
TargetFramework = _targetFramework
};
ApplicationHostContext.Initialize(applicationHostContext);
Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, applicationHostContext.ProjectDirectory);
Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, applicationHostContext.RootDirectory);
Logger.TraceInformation("[{0}]: Project configuration: {1}", GetType().Name, options.Configuration);
Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, applicationHostContext.PackagesDirectory);
_libraryManager = applicationHostContext.LibraryManager;
_project = applicationHostContext.Project;
if (options.WatchFiles)
{
fileWatcher.OnChanged += _ =>
{
_shutdown.RequestShutdownWaitForDebugger();
};
}
// Create a new Application Environment for running the app. It needs a reference to the Host's application environment
// (if any), which we can get from the service provider we were given.
// If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating
// will just have it's own independent set of global data.
var hostEnvironment = (IApplicationEnvironment)hostServices.GetService(typeof(IApplicationEnvironment));
var applicationEnvironment = new ApplicationEnvironment(Project, _targetFramework, options.Configuration, hostEnvironment);
var compilationContext = new CompilationEngineContext(applicationEnvironment, loadContextAccessor.Default, new CompilationCache(), fileWatcher, new ProjectGraphProvider());
// Compilation services available only for runtime compilation
compilationContext.AddCompilationService(typeof(RuntimeOptions), options);
compilationContext.AddCompilationService(typeof(IApplicationShutdown), _shutdown);
var compilationEngine = new CompilationEngine(compilationContext);
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment);
_serviceProvider.Add(typeof(ILibraryManager), _libraryManager);
// TODO: Make this lazy
_serviceProvider.Add(typeof(ILibraryExporter), compilationEngine.CreateProjectExporter(Project, _targetFramework, options.Configuration));
_serviceProvider.Add(typeof(IApplicationShutdown), _shutdown);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), new CompilerOptionsProvider(_libraryManager));
if (options.CompilationServerPort.HasValue)
{
// Change the project reference provider
Project.DefaultCompiler = Project.DefaultDesignTimeCompiler;
}
CallContextServiceLocator.Locator.ServiceProvider = ServiceProvider;
// Configure Assembly loaders
_loaders.Add(new ProjectAssemblyLoader(
loadContextAccessor,
compilationEngine,
_libraryManager));
_loaders.Add(new PackageAssemblyLoader(loadContextAccessor, _libraryManager));
}
