public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory)
{
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Dnx.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath)) {
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
/// <summary>
/// This is a helper method for looking up directories that directly contains assemblies that would be loaded
/// given the published runtime framework. We should run crossgen on these folders
/// </summary>
private IEnumerable<string> ResolveOutputAssemblies(PublishRoot root, NuGetDependencyResolver resolver)
{
var outputPathsMap = root.Packages
.ToDictionary(
pkg => pkg.Library,
pkg => pkg.TargetPath
);
var result = new HashSet<string>();
var libraryNotInOutput = new List<LibraryIdentity>();
var missingOutputFolder = new List<string>();
foreach (var dependency in resolver.PackageAssemblyLookup.Values)
{
var libId = dependency.Library.Identity;
var libPath = dependency.Library.Path;
var assemblyDir = Path.GetDirectoryName(dependency.Path);
var assemblySelection = assemblyDir.Substring(libPath.Length);
string outputLibLocation;
if (!outputPathsMap.TryGetValue(libId, out outputLibLocation))
{
libraryNotInOutput.Add(libId);
continue;
}
var output = outputLibLocation + assemblySelection;
if (!Directory.Exists(output))
{
missingOutputFolder.Add(output);
}
else
{
result.Add(output);
}
}
if (libraryNotInOutput.Any())
{
throw new InvalidOperationException(string.Format("Library {0} cannot be found in the published output.", string.Join(", ", libraryNotInOutput)));
}
if (missingOutputFolder.Any())
{
throw new InvalidOperationException("Published output does not contain directory:\n" + string.Join("\n", missingOutputFolder));
}
return result;
}
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);
}
public void AddLoader(NuGetDependencyResolver nugetLoader)
{
Loaders.Add(nugetLoader);
}
