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));
}
protected override void ExecuteCore()
{
var lockFileCache = new LockFileCache(BuildEngine4);
LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath);
IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
HashSet <PackageIdentity> packagestoBeFiltered = null;
if (TargetManifestFiles != null && TargetManifestFiles.Length > 0)
{
packagestoBeFiltered = new HashSet <PackageIdentity>();
foreach (var manifestFile in TargetManifestFiles)
{
Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.ParsingFiles, manifestFile));
var packagesSpecified = StoreArtifactParser.Parse(manifestFile);
foreach (var pkg in packagesSpecified)
{
Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.PackageInfoLog, pkg.Id, pkg.Version));
}
packagestoBeFiltered.UnionWith(packagesSpecified);
}
}
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName,
IsSelfContained);
projectContext.PackagesToBeFiltered = packagestoBeFiltered;
var assemblyResolver =
new PublishAssembliesResolver(packageResolver)
.WithExcludeFromPublish(excludeFromPublishPackageIds)
.WithPreserveStoreLayout(PreserveStoreLayout);
IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower());
_assembliesToPublish.Add(item);
}
foreach (var resolvedPkg in assemblyResolver.GetResolvedPackages())
{
TaskItem item = new TaskItem(resolvedPkg.Id);
item.SetMetadata("Version", resolvedPkg.Version.ToString());
_packagesResolved.Add(item);
}
}
protected override void ExecuteCore()
{
var lockFileCache = new LockFileCache(this);
LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath);
IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
HashSet <PackageIdentity> packagestoBeFiltered = null;
if (RuntimeStorePackages != null && RuntimeStorePackages.Length > 0)
{
packagestoBeFiltered = new HashSet <PackageIdentity>();
foreach (var package in RuntimeStorePackages)
{
packagestoBeFiltered.Add(ItemUtilities.GetPackageIdentity(package));
}
}
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName,
RuntimeFrameworks,
IsSelfContained);
projectContext.PackagesToBeFiltered = packagestoBeFiltered;
var assemblyResolver =
new PublishAssembliesResolver(packageResolver)
.WithExcludeFromPublish(excludeFromPublishPackageIds)
.WithPreserveStoreLayout(PreserveStoreLayout);
IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower());
item.SetMetadata(MetadataKeys.PackageName, resolvedAssembly.Package.Id.ToString());
item.SetMetadata(MetadataKeys.PackageVersion, resolvedAssembly.Package.Version.ToString().ToLower());
if (resolvedAssembly.Asset == AssetType.Resources)
{
// For resources, the DestinationSubDirectory is set to the locale. Set the Culture
// metadata on the generated item to this value so that the satellite assemblies can
// be filtered by culture.
item.SetMetadata(MetadataKeys.Culture, resolvedAssembly.DestinationSubDirectory);
}
_assembliesToPublish.Add(item);
}
}
protected override void ExecuteCore()
{
var lockFileCache = new LockFileCache(this);
LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath);
HashSet <PackageIdentity> packagestoBeFiltered = null;
if (RuntimeStorePackages != null && RuntimeStorePackages.Length > 0)
{
packagestoBeFiltered = new HashSet <PackageIdentity>();
foreach (var package in RuntimeStorePackages)
{
packagestoBeFiltered.Add(ItemUtilities.GetPackageIdentity(package));
}
}
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName,
RuntimeFrameworks,
IsSelfContained);
projectContext.PackagesToBeFiltered = packagestoBeFiltered;
var assetsFileResolver =
new AssetsFileResolver(NuGetPackageResolver.CreateResolver(lockFile))
.WithExcludedPackages(PackageReferenceConverter.GetPackageIds(ExcludedPackageReferences))
.WithPreserveStoreLayout(PreserveStoreLayout);
foreach (var resolvedFile in assetsFileResolver.Resolve(projectContext))
{
TaskItem item = new TaskItem(resolvedFile.SourcePath);
item.SetMetadata(MetadataKeys.DestinationSubPath, resolvedFile.DestinationSubPath);
item.SetMetadata(MetadataKeys.DestinationSubDirectory, resolvedFile.DestinationSubDirectory);
item.SetMetadata(MetadataKeys.AssetType, resolvedFile.Asset.ToString().ToLowerInvariant());
item.SetMetadata(MetadataKeys.PackageName, resolvedFile.Package.Id.ToString());
item.SetMetadata(MetadataKeys.PackageVersion, resolvedFile.Package.Version.ToString().ToLowerInvariant());
if (resolvedFile.Asset == AssetType.Resources)
{
// For resources, the DestinationSubDirectory is set to the locale. Set the Culture
// metadata on the generated item to this value so that the satellite assemblies can
// be filtered by culture.
item.SetMetadata(MetadataKeys.Culture, resolvedFile.DestinationSubDirectory.TrimEnd(Path.DirectorySeparatorChar));
}
_resolvedAssets.Add(item);
}
}
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));
}
protected override void ExecuteCore()
{
LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath);
NuGetPathContext nugetPathContext = NuGetPathContext.Create(Path.GetDirectoryName(ProjectPath));
IEnumerable <string> privateAssetsPackageIds = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences);
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName);
IEnumerable <ResolvedFile> resolvedAssemblies =
new PublishAssembliesResolver(new NuGetPackageResolver(nugetPathContext))
.WithPrivateAssets(privateAssetsPackageIds)
.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
_assembliesToPublish.Add(item);
}
}
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));
}
