private Task InstallPackageAsync(string source, Project project, string packageId, NuGetVersion version, bool includePrerelease, bool ignoreDependencies)
{
IEnumerable <string> sources = null;
if (!string.IsNullOrEmpty(source) &&
!StringComparer.OrdinalIgnoreCase.Equals("All", source)) // "All" was supported in V2
{
sources = new[] { source };
}
var toInstall = new List <PackageIdentity>
{
new PackageIdentity(packageId, version)
};
var projectContext = new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
return(InstallInternalAsync(project, toInstall, GetSources(sources), projectContext, includePrerelease, ignoreDependencies, CancellationToken.None));
}
private async Task <IEnumerable <PackageReference> > GetInstalledPackageReferencesAsync(
Project project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var packages = new List <PackageReference>();
if (_solutionManager != null &&
!string.IsNullOrEmpty(await _solutionManager.GetSolutionDirectoryAsync()))
{
var projectContext = new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(
project,
projectContext);
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
packages.AddRange(installedPackages);
}
return(packages);
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
const string eventName = nameof(IVsPackageUninstaller) + "." + nameof(UninstallPackage);
using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName,
new
{
// Can't add project information, since it's a COM object that this method might be called on a background thread
PackageId = packageId,
RemoveDependencies = removeDependencies
});
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (string.IsNullOrEmpty(packageId))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageId)));
}
try
{
PumpingJTF.Run(async delegate
{
NuGetPackageManager packageManager =
new NuGetPackageManager(
_sourceRepositoryProvider,
_settings,
_solutionManager,
_deleteOnRestartManager,
_restoreProgressReporter);
var uninstallContext = new UninstallationContext(removeDependencies, forceRemove: false);
var projectContext = new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
// find the project
NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext);
// uninstall the package
await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None);
});
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPackageUninstaller).FullName);
throw;
}
}
public void InstallPackagesFromVSExtensionRepositoryImpl(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions)
{
if (string.IsNullOrEmpty(extensionId))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(extensionId));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (!packageVersions.Any())
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions));
}
try
{
PumpingJTF.Run(() =>
{
var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider);
repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId);
var toInstall = GetIdentitiesFromDict(packageVersions);
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = skipAssemblyReferences;
var projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects)
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
return(InstallInternalAsync(
project,
toInstall,
repoProvider,
projectContext,
includePrerelease: false,
ignoreDependencies: ignoreDependencies,
token: CancellationToken.None));
});
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPackageInstaller).FullName);
throw;
}
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// This does not check for already installed packages
/// </summary>
internal async Task InstallInternalCoreAsync(
NuGetPackageManager packageManager,
GatherCache gatherCache,
NuGetProject nuGetProject,
PackageIdentity package,
IEnumerable <SourceRepository> sources,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
await TaskScheduler.Default;
var depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
using (var sourceCacheContext = new SourceCacheContext())
{
var resolution = new ResolutionContext(
depBehavior,
includePrerelease,
includeUnlisted: false,
versionConstraints: VersionConstraints.None,
gatherCache: gatherCache,
sourceCacheContext: sourceCacheContext);
// install the package
if (package.Version == null)
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
else
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
}
}
/// <summary>
/// Internal install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternalAsync(
Project project,
List <PackageIdentity> packages,
ISourceRepositoryProvider repoProvider,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
// Go off the UI thread. This may be called from the UI thread. Only switch to the UI thread where necessary
// This method installs multiple packages and can likely take more than a few secs
// So, go off the UI thread explicitly to improve responsiveness
await TaskScheduler.Default;
var gatherCache = new GatherCache();
var sources = repoProvider.GetRepositories().ToList();
// store expanded node state
var expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync();
try
{
var depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
var packageManager = CreatePackageManager(repoProvider);
// find the project
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext);
var packageManagementFormat = new PackageManagementFormat(_settings);
// 1 means PackageReference
var preferPackageReference = packageManagementFormat.SelectedPackageManagementFormat == 1;
// Check if default package format is set to `PackageReference` and project has no
// package installed yet then upgrade it to `PackageReference` based project.
if (preferPackageReference &&
(nuGetProject is MSBuildNuGetProject) &&
!(await nuGetProject.GetInstalledPackagesAsync(token)).Any() &&
await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject, project, needsAPackagesConfig: false))
{
nuGetProject = await _solutionManager.UpgradeProjectToPackageReferenceAsync(nuGetProject);
}
// install the package
foreach (var package in packages)
{
var installedPackageReferences = await nuGetProject.GetInstalledPackagesAsync(token);
// Check if the package is already installed
if (package.Version != null &&
PackageServiceUtilities.IsPackageInList(installedPackageReferences, package.Id, package.Version))
{
continue;
}
// Perform the install
await InstallInternalCoreAsync(
packageManager,
gatherCache,
nuGetProject,
package,
sources,
projectContext,
includePrerelease,
ignoreDependencies,
token);
}
}
finally
{
// collapse nodes
await VsHierarchyUtility.CollapseAllNodesAsync(expandedNodes);
}
}
public void InstallPackagesFromRegistryRepositoryImpl(string keyName, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions)
{
if (string.IsNullOrEmpty(keyName))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(keyName));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (packageVersions == null ||
!packageVersions.Any())
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions));
}
try
{
PumpingJTF.Run(async() =>
{
// HACK !!! : This is a hack for PCL projects which send isPreUnzipped = true, but their package source
// (located at C:\Program Files (x86)\Microsoft SDKs\NuGetPackages) follows the V3
// folder version format.
if (isPreUnzipped)
{
var isProjectJsonProject = await EnvDTEProjectUtility.HasBuildIntegratedConfig(project);
isPreUnzipped = isProjectJsonProject ? false : isPreUnzipped;
}
// create a repository provider with only the registry repository
var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider);
repoProvider.AddFromRegistry(keyName, isPreUnzipped);
var toInstall = GetIdentitiesFromDict(packageVersions);
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = skipAssemblyReferences;
var projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects)
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
await InstallInternalAsync(
project,
toInstall,
repoProvider,
projectContext,
includePrerelease: false,
ignoreDependencies: ignoreDependencies,
token: CancellationToken.None);
});
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPackageInstaller).FullName);
throw;
}
}
public IEnumerable <IVsPackageMetadata> GetInstalledPackages(Project project)
{
const string eventName = nameof(IVsPackageInstallerServices) + "." + nameof(GetInstalledPackages) + ".1";
using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName);
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
try
{
return(_threadingService.JoinableTaskFactory.Run(async delegate
{
var packages = new List <IVsPackageMetadata>();
if (_solutionManager != null &&
!string.IsNullOrEmpty(await _solutionManager.GetSolutionDirectoryAsync()))
{
//switch to background thread
await TaskScheduler.Default;
NuGetPackageManager nuGetPackageManager = CreateNuGetPackageManager();
var projectContext = new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(
project,
projectContext);
if (nuGetProject != null)
{
FallbackPackagePathResolver pathResolver = null;
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
if (buildIntegratedProject != null)
{
pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject);
}
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
foreach (var package in installedPackages)
{
if (!package.PackageIdentity.HasVersion)
{
// Currently we are not supporting floating versions
// because of that we will skip this package so that it doesn't throw ArgumentNullException
continue;
}
string installPath;
if (buildIntegratedProject != null)
{
installPath = pathResolver.GetPackageDirectory(package.PackageIdentity.Id, package.PackageIdentity.Version);
}
else
{
// Get the install path for package
installPath = nuGetPackageManager.PackagesFolderNuGetProject.GetInstalledPath(
package.PackageIdentity);
if (!string.IsNullOrEmpty(installPath))
{
// normalize the path and take the dir if the nupkg path was given
var dir = new DirectoryInfo(installPath);
installPath = dir.FullName;
}
}
var metadata = new VsPackageMetadata(package.PackageIdentity, installPath);
packages.Add(metadata);
}
}
}
return packages;
}));
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsPackageInstallerServices).FullName);
throw;
}
}
