public static NuGetPackageResolver CreateResolver(IEnumerable <string> packageFolders, string projectPath)
{
NuGetPackageResolver packageResolver;
string userPackageFolder = packageFolders.FirstOrDefault();
if (userPackageFolder != null)
{
var fallBackFolders = packageFolders.Skip(1);
packageResolver = new NuGetPackageResolver(userPackageFolder, fallBackFolders);
}
else
{
NuGetPathContext nugetPathContext = NuGetPathContext.Create(Path.GetDirectoryName(projectPath));
packageResolver = new NuGetPackageResolver(nugetPathContext);
}
return(packageResolver);
}
public static NuGetPackageResolver CreateResolver(LockFile lockFile, string projectPath)
{
NuGetPackageResolver packageResolver;
string userPackageFolder = lockFile.PackageFolders.FirstOrDefault()?.Path;
if (userPackageFolder != null)
{
var fallBackFolders = lockFile.PackageFolders.Skip(1).Select(f => f.Path);
packageResolver = new NuGetPackageResolver(userPackageFolder, fallBackFolders);
}
else
{
NuGetPathContext nugetPathContext = NuGetPathContext.Create(Path.GetDirectoryName(projectPath));
packageResolver = new NuGetPackageResolver(nugetPathContext);
}
return(packageResolver);
}
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 (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,
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().ToLower());
item.SetMetadata(MetadataKeys.PackageVersion, resolvedAssembly.Package.Version.ToString().ToLower());
_assembliesToPublish.Add(item);
}
}
protected override void ExecuteCore()
{
if (Items.Length == 0 || PackageFolders.Length == 0)
{
Output = Items;
return;
}
var packageResolver = NuGetPackageResolver.CreateResolver(PackageFolders);
int index = 0;
var updatedItems = new ITaskItem[Items.Length];
foreach (var item in Items)
{
string packageName = item.GetMetadata(MetadataKeys.PackageName);
string packageVersion = item.GetMetadata(MetadataKeys.PackageVersion);
if (string.IsNullOrEmpty(packageName) || string.IsNullOrEmpty(packageVersion) ||
!string.IsNullOrEmpty(item.GetMetadata(MetadataKeys.PackageDirectory)))
{
updatedItems[index++] = item;
continue;
}
var parsedPackageVersion = NuGetVersion.Parse(packageVersion);
string packageDirectory = packageResolver.GetPackageDirectory(packageName, parsedPackageVersion);
if (packageDirectory == null)
{
updatedItems[index++] = item;
continue;
}
var newItem = new TaskItem(item);
newItem.SetMetadata(MetadataKeys.PackageDirectory, packageDirectory);
updatedItems[index++] = newItem;
}
Output = updatedItems;
}
protected override void ExecuteCore()
{
if (Items != null)
{
NuGetPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(PackageFolders, ProjectPath);
var updatedItems = new List <ITaskItem>();
foreach (var item in Items)
{
string packageName = item.GetMetadata(MetadataKeys.PackageName);
string packageVersion = item.GetMetadata(MetadataKeys.PackageVersion);
if (!string.IsNullOrEmpty(packageName) && !string.IsNullOrEmpty(packageVersion) &&
string.IsNullOrEmpty(item.GetMetadata(MetadataKeys.PackageDirectory)))
{
var newItem = new TaskItem(item);
// Gracefully handle case where we don't have a packageResolver because we don't have an assets
// file, which happens for design-time builds
if (packageResolver != null)
{
var parsedPackageVersion = NuGetVersion.Parse(packageVersion);
string packageDirectory = packageResolver.GetPackageDirectory(packageName, parsedPackageVersion);
newItem.SetMetadata(MetadataKeys.PackageDirectory, packageDirectory);
}
updatedItems.Add(newItem);
}
else
{
updatedItems.Add(item);
}
}
Output = updatedItems.ToArray();
}
}
public DependencyContextBuilder(SingleProjectInfo mainProjectInfo, ProjectContext projectContext, bool includeRuntimeFileVersions)
{
_mainProjectInfo = mainProjectInfo;
_projectContext = projectContext;
_includeRuntimeFileVersions = includeRuntimeFileVersions;
// This resolver is only used for building file names, so that base path is not required.
_versionFolderPathResolver = new VersionFolderPathResolver(rootPath: null);
if (_includeRuntimeFileVersions)
{
// This is used to look up the paths to package files on disk, which is only needed in this class if
// it needs to read the file versions
_packageResolver = NuGetPackageResolver.CreateResolver(projectContext.LockFile);
}
if (_projectContext.CompilationLockFileTarget != _projectContext.LockFileTarget)
{
_compilationTargetLibraries = _projectContext.CompilationLockFileTarget.Libraries
.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
}
}
protected override void ExecuteCore()
{
LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath);
IEnumerable <string> privateAssetsPackageIds = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName);
IEnumerable <ResolvedFile> resolvedAssemblies =
new PublishAssembliesResolver(packageResolver)
.WithPrivateAssets(privateAssetsPackageIds)
.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
_assembliesToPublish.Add(item);
}
}
protected override void ExecuteCore()
{
var lockFile = new LockFileCache(BuildEngine4).GetLockFile(ProjectAssetsFile);
_packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
var targetFramework = NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker);
var compileTimeTarget = lockFile.GetTargetAndThrowIfNotFound(targetFramework, runtime: null);
var runtimeTarget = lockFile.GetTargetAndThrowIfNotFound(targetFramework, RuntimeIdentifier);
CheckRuntimePackageDependencies(compileTimeTarget, runtimeTarget);
Analyzers = RaiseAnalyzers(
lockFile,
runtimeTarget);
CompileTimeAssemblies = RaisePackageAssets(
compileTimeTarget,
package => package.CompileTimeAssemblies,
setup: (asset, item) =>
{
item.SetMetadata(MetadataKeys.Private, "false");
item.SetMetadata(MetadataKeys.HintPath, item.ItemSpec);
if (MarkPackageReferencesAsExternallyResolved)
{
item.SetMetadata(MetadataKeys.ExternallyResolved, "true");
}
});
if (!DisableFrameworkAssemblies)
{
FrameworkAssemblies = RaiseFrameworkAssemblies(
compileTimeTarget,
setup: (asset, item) =>
{
item.SetMetadata(MetadataKeys.Pack, "false");
item.SetMetadata(MetadataKeys.Private, "false");
item.SetMetadata(MetadataKeys.NuGetIsFrameworkReference, "true");
});
}
ContentFilesToPreprocess = RaisePackageAssets(
runtimeTarget,
p => p.ContentFiles,
filter: asset => !string.IsNullOrEmpty(asset.PPOutputPath),
setup: (asset, item) =>
{
item.SetMetadata(MetadataKeys.BuildAction, asset.BuildAction.ToString());
item.SetMetadata(MetadataKeys.CopyToOutput, asset.CopyToOutput.ToString());
item.SetMetadata(MetadataKeys.PPOutputPath, asset.PPOutputPath);
if (!string.IsNullOrEmpty(MetadataKeys.OutputPath))
{
item.SetMetadata(MetadataKeys.OutputPath, asset.OutputPath);
}
if (!string.IsNullOrEmpty(asset.CodeLanguage))
{
item.SetMetadata(MetadataKeys.CodeLanguage, asset.CodeLanguage);
}
});
NativeLibraries = RaisePackageAssets(
runtimeTarget,
package => package.NativeLibraries);
ResourceAssemblies = RaisePackageAssets(
runtimeTarget,
package => package.ResourceAssemblies,
setup: (asset, item) =>
{
string locale = asset.Properties["locale"];
item.SetMetadata(MetadataKeys.Culture, locale);
item.SetMetadata(MetadataKeys.DestinationSubDirectory, locale + Path.DirectorySeparatorChar);
});
RuntimeAssemblies = RaisePackageAssets(
runtimeTarget,
package => package.RuntimeAssemblies);
RuntimeTargets = RaisePackageAssets(
runtimeTarget,
package => package.RuntimeTargets,
setup: (asset, item) =>
{
string directory = Path.GetDirectoryName(asset.Path);
item.SetMetadata(MetadataKeys.DestinationSubDirectory, directory + Path.DirectorySeparatorChar);
});
if (!DisableTransitiveProjectReferences)
{
TransitiveProjectReferences = RaiseTransitiveProjectReferences(lockFile, runtimeTarget);
}
}
