public LockFileLookup(LockFile lockFile)
{
_packages = new Dictionary<Tuple<string, SemanticVersion>, LockFilePackageLibrary>();
_projects = new Dictionary<string, LockFileProjectLibrary>();
foreach (var library in lockFile.PackageLibraries)
{
_packages[Tuple.Create(library.Name, library.Version)] = library;
}
foreach (var libary in lockFile.ProjectLibraries)
{
_projects[libary.Name] = libary;
}
}
public LockFileLookup(LockFile lockFile)
{
_lookup = new Dictionary<Tuple<string, FrameworkName, string>, LockFileTargetLibrary>();
_packages = new Dictionary<Tuple<string, SemanticVersion>, LockFilePackageLibrary>();
foreach (var t in lockFile.Targets)
{
foreach (var library in t.Libraries)
{
// Each target has a single package version per id
_lookup[Tuple.Create(t.RuntimeIdentifier, t.TargetFramework, library.Name)] = library;
}
}
foreach (var library in lockFile.PackageLibraries)
{
_packages[Tuple.Create(library.Name, library.Version)] = library;
}
}
private void AssertLockFileTarget(LockFile lockFile, string searchRid, string assemblyRid)
{
var target = lockFile.Targets.SingleOrDefault(t => t.TargetFramework == Dnx451 && string.Equals(t.RuntimeIdentifier, searchRid, StringComparison.Ordinal));
Assert.NotNull(target);
var library = target.Libraries.SingleOrDefault(l => l.Name.Equals("RuntimeRestoreTest"));
Assert.NotNull(library);
if (string.IsNullOrEmpty(assemblyRid))
{
AssertLockFileItemPath("lib/dnx451/RuntimeRestoreTest.dll", library.CompileTimeAssemblies.Single());
AssertLockFileItemPath("lib/dnx451/RuntimeRestoreTest.dll", library.RuntimeAssemblies.Single());
}
else
{
AssertLockFileItemPath($"runtimes/{assemblyRid}/lib/dnx451/RuntimeRestoreTest.dll", library.CompileTimeAssemblies.Single());
AssertLockFileItemPath($"runtimes/{assemblyRid}/lib/dnx451/RuntimeRestoreTest.dll", library.RuntimeAssemblies.Single());
}
}
private void WriteLockFile(string dir, string libName, string version)
{
var lockFile = new LockFile
{
Islocked = false,
PackageLibraries = new List<LockFilePackageLibrary>
{
new LockFilePackageLibrary
{
Name = libName,
Version = new SemanticVersion(version),
Sha512 = "TestSha"
}
}
};
var lockFormat = new LockFileFormat();
lockFormat.Write($"{dir}/project.lock.json", lockFile);
}
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 static bool HasTarget(this LockFile self, FrameworkName framework, string runtimeIdentifier)
{
return(self.Targets.Any(t => t.TargetFramework == framework && string.Equals(t.RuntimeIdentifier, runtimeIdentifier, StringComparison.Ordinal)));
}
public static bool HasTarget(this LockFile self, FrameworkName framework)
{
return(self.Targets.Any(t => t.TargetFramework == framework && string.IsNullOrEmpty(t.RuntimeIdentifier)));
}
private static LockFileTarget SelectTarget(ApplicationHostContext context, LockFile lockFile)
{
foreach (var runtimeIdentifier in context.RuntimeIdentifiers)
{
foreach (var scanTarget in lockFile.Targets)
{
if (scanTarget.TargetFramework == context.TargetFramework && string.Equals(scanTarget.RuntimeIdentifier, runtimeIdentifier, StringComparison.Ordinal))
{
return scanTarget;
}
}
}
foreach (var scanTarget in lockFile.Targets)
{
if (scanTarget.TargetFramework == context.TargetFramework && string.IsNullOrEmpty(scanTarget.RuntimeIdentifier))
{
return scanTarget;
}
}
return null;
}
public void ApplyLockFile(LockFile lockFile)
{
var stringComparer = _checkPackageIdCase ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
_lockFileLibraries = lockFile.PackageLibraries
.ToLookup(l => l.Name, stringComparer);
}
