private static IEnumerable <ReferenceInfo> CreateFilteredReferenceInfos( IEnumerable <ITaskItem> referencePaths, IEnumerable <ITaskItem> referenceSatellitePaths) { Dictionary <string, ReferenceInfo> directReferences = new Dictionary <string, ReferenceInfo>(); foreach (ITaskItem referencePath in referencePaths) { ReferenceInfo referenceInfo = CreateReferenceInfo(referencePath); directReferences.Add(referenceInfo.FullPath, referenceInfo); } foreach (ITaskItem referenceSatellitePath in referenceSatellitePaths) { string originalItemSpec = referenceSatellitePath.GetMetadata("OriginalItemSpec"); if (!string.IsNullOrEmpty(originalItemSpec)) { ReferenceInfo referenceInfo; if (directReferences.TryGetValue(originalItemSpec, out referenceInfo)) { ResourceAssemblyInfo resourceAssemblyInfo = ResourceAssemblyInfo.CreateFromReferenceSatellitePath(referenceSatellitePath); referenceInfo._resourceAssemblies.Add(resourceAssemblyInfo); } } } return(directReferences.Values); }
public static IEnumerable <ReferenceInfo> CreateDirectReferenceInfos( IEnumerable <ITaskItem> referencePaths, IEnumerable <ITaskItem> referenceSatellitePaths) { IEnumerable <ITaskItem> directReferencePaths = referencePaths .Where(r => r.HasMetadataValue("CopyLocal", "true") && r.HasMetadataValue("ReferenceSourceTarget", "ResolveAssemblyReference") && string.IsNullOrEmpty(r.GetMetadata("NuGetSourceType"))); Dictionary <string, ReferenceInfo> directReferences = new Dictionary <string, ReferenceInfo>(); foreach (ITaskItem directReferencePath in directReferencePaths) { ReferenceInfo referenceInfo = CreateReferenceInfo(directReferencePath); directReferences.Add(referenceInfo.FullPath, referenceInfo); } foreach (ITaskItem referenceSatellitePath in referenceSatellitePaths) { string originalItemSpec = referenceSatellitePath.GetMetadata("OriginalItemSpec"); if (!string.IsNullOrEmpty(originalItemSpec)) { ReferenceInfo referenceInfo; if (directReferences.TryGetValue(originalItemSpec, out referenceInfo)) { ResourceAssemblyInfo resourceAssemblyInfo = ResourceAssemblyInfo.CreateFromReferenceSatellitePath(referenceSatellitePath); referenceInfo._resourceAssemblies.Add(resourceAssemblyInfo); } } } return(directReferences.Values); }
protected override void ExecuteCore() { LoadFilesToSkip(); LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> frameworkReferences = ReferenceInfo.CreateFrameworkReferenceInfos(ReferencePaths); IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceSatellitePaths); IEnumerable <string> excludeFromPublishAssets = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, IsSelfContained); DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext) .WithMainProjectInDepsFile(IncludeMainProject) .WithFrameworkReferences(frameworkReferences) .WithDirectReferences(directReferences) .WithReferenceProjectInfos(referenceProjects) .WithExcludeFromPublishAssets(excludeFromPublishAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWhereFiltered(GetFilteredPackages()) .Build(); if (compileFilesToSkip.Any() || runtimeFilesToSkip.Any()) { dependencyContext = TrimFilesToSkip(dependencyContext); } var writer = new DependencyContextWriter(); using (var fileStream = File.Create(DepsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(DepsFilePath)); }
private string GetReferenceLibraryName(ReferenceInfo reference) { if (!ReferenceLibraryNames.TryGetValue(reference, out string name)) { // Reference names can conflict with PackageReference names, so // ensure that the Reference names are unique when creating libraries name = GetUniqueReferenceName(reference.Name); ReferenceLibraryNames.Add(reference, name); _usedLibraryNames.Add(name); } return(name); }
protected override void ExecuteCore() { LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> frameworkReferences = ReferenceInfo.CreateFrameworkReferenceInfos(ReferencePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceSatellitePaths); IEnumerable <string> privateAssets = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName); DependencyContext dependencyContext = new DependencyContextBuilder(mainProject, projectContext) .WithFrameworkReferences(frameworkReferences) .WithReferenceProjectInfos(referenceProjects) .WithPrivateAssets(privateAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(DepsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(DepsFilePath)); }
private void WriteDepsFile(string depsFilePath) { ProjectContext projectContext; if (AssetsFilePath == null) { projectContext = null; } else { LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); projectContext = lockFile.CreateProjectContext( TargetFramework, RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); } CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); var userRuntimeAssemblySet = new HashSet <string>(UserRuntimeAssemblies ?? Enumerable.Empty <string>(), StringComparer.OrdinalIgnoreCase); Func <ITaskItem, bool> isUserRuntimeAssembly = item => userRuntimeAssemblySet.Contains(item.ItemSpec); IEnumerable <ReferenceInfo> referenceAssemblyInfos = ReferenceInfo.CreateReferenceInfos(ReferenceAssemblies); // If there is a generated asset file. The projectContext will have project reference. // So remove it from directReferences to avoid duplication var projectContextHasProjectReferences = projectContext != null; IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths, projectContextHasProjectReferences, isUserRuntimeAssembly); IEnumerable <ReferenceInfo> dependencyReferences = ReferenceInfo.CreateDependencyReferenceInfos(ReferenceDependencyPaths, ReferenceSatellitePaths, isUserRuntimeAssembly); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos(ReferencePaths, ReferenceSatellitePaths, isUserRuntimeAssembly); bool ShouldIncludeRuntimeAsset(ITaskItem item) { if (IsSelfContained) { if (!IsSingleFile || !item.GetMetadata(MetadataKeys.DropFromSingleFile).Equals("true")) { return(true); } } else if (item.HasMetadataValue(MetadataKeys.RuntimePackAlwaysCopyLocal, "true")) { return(true); } return(false); } IEnumerable <RuntimePackAssetInfo> runtimePackAssets = RuntimePackAssets.Where(ShouldIncludeRuntimeAsset).Select(RuntimePackAssetInfo.FromItem); DependencyContextBuilder builder; if (projectContext != null) { // Generate the RID-fallback for self-contained builds. // // In order to support loading components with RID-specific assets, // the AssemblyDependencyResolver requires a RID fallback graph. // The component itself should not carry the RID fallback graph with it, because // it would need to carry graph of all the RIDs and needs updates for newer RIDs. // For framework dependent apps, the RID fallback graph comes from the core framework Microsoft.NETCore.App, // so there is no need to write it into the app. // If self-contained apps, the (applicable subset of) RID fallback graph needs to be written to the deps.json manifest. // // If a RID-graph is provided to the DependencyContextBuilder, it generates a RID-fallback // graph with respect to the target RuntimeIdentifier. RuntimeGraph runtimeGraph = IsSelfContained ? new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath) : null; builder = new DependencyContextBuilder(mainProject, IncludeRuntimeFileVersions, runtimeGraph, projectContext); } else { builder = new DependencyContextBuilder( mainProject, IncludeRuntimeFileVersions, RuntimeFrameworks, isSelfContained: IsSelfContained, platformLibraryName: PlatformLibraryName, runtimeIdentifier: RuntimeIdentifier, targetFramework: TargetFramework); } builder = builder .WithMainProjectInDepsFile(IncludeMainProject) .WithReferenceAssemblies(referenceAssemblyInfos) .WithDirectReferences(directReferences) .WithDependencyReferences(dependencyReferences) .WithReferenceProjectInfos(referenceProjects) .WithRuntimePackAssets(runtimePackAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWereFiltered(GetFilteredPackages()); if (CompileReferences.Length > 0) { builder = builder.WithCompileReferences(ReferenceInfo.CreateReferenceInfos(CompileReferences)); } var resolvedNuGetFiles = ResolvedNuGetFiles.Select(f => new ResolvedFile(f, false)) .Concat(ResolvedRuntimeTargetsFiles.Select(f => new ResolvedFile(f, true))); builder = builder.WithResolvedNuGetFiles(resolvedNuGetFiles); DependencyContext dependencyContext = builder.Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(depsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(depsFilePath)); }
private void WriteDepsFileNew(string depsFilePath) { LockFile lockFile = new LockFileCache(this).GetLockFile(AssetsFilePath); CompilationOptions compilationOptions = CompilationOptionsConverter.ConvertFrom(CompilerOptions); SingleProjectInfo mainProject = SingleProjectInfo.Create( ProjectPath, AssemblyName, AssemblyExtension, AssemblyVersion, AssemblySatelliteAssemblies); IEnumerable <ReferenceInfo> referenceAssemblyInfos = ReferenceInfo.CreateReferenceInfos(ReferenceAssemblies); IEnumerable <ReferenceInfo> directReferences = ReferenceInfo.CreateDirectReferenceInfos(ReferencePaths, ReferenceSatellitePaths); IEnumerable <ReferenceInfo> dependencyReferences = ReferenceInfo.CreateDependencyReferenceInfos(ReferenceDependencyPaths, ReferenceSatellitePaths); Dictionary <string, SingleProjectInfo> referenceProjects = SingleProjectInfo.CreateProjectReferenceInfos( ReferencePaths, ReferenceDependencyPaths, ReferenceSatellitePaths); IEnumerable <string> excludeFromPublishAssets = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences); IEnumerable <RuntimePackAssetInfo> runtimePackAssets = RuntimePackAssets.Select(item => RuntimePackAssetInfo.FromItem(item)); ProjectContext projectContext = lockFile.CreateProjectContext( NuGetUtils.ParseFrameworkName(TargetFramework), RuntimeIdentifier, PlatformLibraryName, RuntimeFrameworks, IsSelfContained); var builder = new DependencyContextBuilder2(mainProject, projectContext, IncludeRuntimeFileVersions); builder = builder .WithMainProjectInDepsFile(IncludeMainProject) .WithReferenceAssemblies(referenceAssemblyInfos) .WithDirectReferences(directReferences) .WithDependencyReferences(dependencyReferences) .WithReferenceProjectInfos(referenceProjects) .WithExcludeFromPublishAssets(excludeFromPublishAssets) .WithRuntimePackAssets(runtimePackAssets) .WithCompilationOptions(compilationOptions) .WithReferenceAssembliesPath(FrameworkReferenceResolver.GetDefaultReferenceAssembliesPath()) .WithPackagesThatWereFiltered(GetFilteredPackages()); if (CompileReferences.Length > 0) { builder = builder.WithCompileReferences(ReferenceInfo.CreateReferenceInfos(CompileReferences)); } var resolvedNuGetFiles = ResolvedNuGetFiles.Select(f => new ResolvedFile(f, false)) .Concat(ResolvedRuntimeTargetsFiles.Select(f => new ResolvedFile(f, true))); builder = builder.WithResolvedNuGetFiles(resolvedNuGetFiles); DependencyContext dependencyContext = builder.Build(); var writer = new DependencyContextWriter(); using (var fileStream = File.Create(depsFilePath)) { writer.Write(dependencyContext, fileStream); } _filesWritten.Add(new TaskItem(depsFilePath)); }
public static Dictionary <string, SingleProjectInfo> CreateProjectReferenceInfos( IEnumerable <ITaskItem> referencePaths, IEnumerable <ITaskItem> referenceDependencyPaths, IEnumerable <ITaskItem> referenceSatellitePaths) { Dictionary <string, SingleProjectInfo> projectReferences = new Dictionary <string, SingleProjectInfo>(StringComparer.OrdinalIgnoreCase); IEnumerable <ITaskItem> projectReferencePaths = referencePaths .Where(r => string.Equals(r.GetMetadata(MetadataKeys.ReferenceSourceTarget), "ProjectReference", StringComparison.OrdinalIgnoreCase)); foreach (ITaskItem projectReferencePath in projectReferencePaths) { string sourceProjectFile = projectReferencePath.GetMetadata(MetadataKeys.MSBuildSourceProjectFile); if (string.IsNullOrEmpty(sourceProjectFile)) { throw new BuildErrorException(Strings.MissingItemMetadata, MetadataKeys.MSBuildSourceProjectFile, "ReferencePath", projectReferencePath.ItemSpec); } string outputName = Path.GetFileName(projectReferencePath.ItemSpec); string name = Path.GetFileNameWithoutExtension(outputName); string version = null; // it isn't possible to know the version from the MSBuild info. // The version will be retrieved from the project assets file. projectReferences.Add( sourceProjectFile, new SingleProjectInfo(sourceProjectFile, name, version, outputName, dependencyReferences: null, resourceAssemblies: null)); } // Include direct references of referenced projects, but only if they are CopyLocal IEnumerable <ITaskItem> projectReferenceDependencyPaths = referenceDependencyPaths .Where(r => string.Equals(r.GetMetadata(MetadataKeys.ReferenceSourceTarget), "ProjectReference", StringComparison.OrdinalIgnoreCase) && MSBuildUtilities.ConvertStringToBool(r.GetMetadata(MetadataKeys.CopyLocal))); foreach (ITaskItem projectReferenceDependencyPath in projectReferenceDependencyPaths) { string sourceProjectFile = projectReferenceDependencyPath.GetMetadata(MetadataKeys.MSBuildSourceProjectFile); if (string.IsNullOrEmpty(sourceProjectFile)) { throw new BuildErrorException(Strings.MissingItemMetadata, MetadataKeys.MSBuildSourceProjectFile, "ReferenceDependencyPath", projectReferenceDependencyPath.ItemSpec); } SingleProjectInfo referenceProjectInfo; if (projectReferences.TryGetValue(sourceProjectFile, out referenceProjectInfo)) { ReferenceInfo dependencyReferenceInfo = ReferenceInfo.CreateReferenceInfo(projectReferenceDependencyPath); referenceProjectInfo._dependencyReferences.Add(dependencyReferenceInfo); } } IEnumerable <ITaskItem> projectReferenceSatellitePaths = referenceSatellitePaths .Where(r => string.Equals(r.GetMetadata(MetadataKeys.ReferenceSourceTarget), "ProjectReference", StringComparison.OrdinalIgnoreCase)); foreach (ITaskItem projectReferenceSatellitePath in projectReferenceSatellitePaths) { string sourceProjectFile = projectReferenceSatellitePath.GetMetadata(MetadataKeys.MSBuildSourceProjectFile); if (string.IsNullOrEmpty(sourceProjectFile)) { throw new BuildErrorException(Strings.MissingItemMetadata, MetadataKeys.MSBuildSourceProjectFile, "ReferenceSatellitePath", projectReferenceSatellitePath.ItemSpec); } SingleProjectInfo referenceProjectInfo; if (projectReferences.TryGetValue(sourceProjectFile, out referenceProjectInfo)) { string originalItemSpec = projectReferenceSatellitePath.GetMetadata(MetadataKeys.OriginalItemSpec); if (!string.IsNullOrEmpty(originalItemSpec)) { ReferenceInfo referenceInfo = referenceProjectInfo._dependencyReferences.SingleOrDefault(r => r.FullPath.Equals(originalItemSpec)); if (referenceInfo is null) { // We only want to add the reference satellite path if it isn't already covered by a dependency ResourceAssemblyInfo resourceAssemblyInfo = ResourceAssemblyInfo.CreateFromReferenceSatellitePath(projectReferenceSatellitePath); referenceProjectInfo._resourceAssemblies.Add(resourceAssemblyInfo); } } } } return(projectReferences); }