public async ValueTask <IReadOnlyCollection <IProjectContextInfo> > GetUpgradeableProjectsAsync(
IReadOnlyCollection <string> projectIds,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
cancellationToken.ThrowIfCancellationRequested();
NuGetProject[] projects = await GetProjectsAsync(projectIds);
var upgradeableProjects = new List <IProjectContextInfo>();
IEnumerable <NuGetProject> capableProjects = projects
.Where(project =>
project.ProjectStyle == ProjectModel.ProjectStyle.PackagesConfig &&
project.ProjectServices.Capabilities.SupportsPackageReferences);
// get all packages.config based projects with no installed packages
foreach (NuGetProject project in capableProjects)
{
IEnumerable <PackageReference> installedPackages = await project.GetInstalledPackagesAsync(cancellationToken);
if (!installedPackages.Any())
{
IProjectContextInfo upgradeableProject = await ProjectContextInfo.CreateAsync(project, cancellationToken);
upgradeableProjects.Add(upgradeableProject);
}
}
return(upgradeableProjects);
}
public async ValueTask <IProjectContextInfo> GetProjectAsync(string projectId, CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectId);
cancellationToken.ThrowIfCancellationRequested();
NuGetProject?project = await SolutionUtility.GetNuGetProjectAsync(
_sharedState.SolutionManager,
projectId,
cancellationToken);
Assumes.NotNull(project);
return(await ProjectContextInfo.CreateAsync(project, cancellationToken));
}
public async ValueTask <IProjectContextInfo> UpgradeProjectToPackageReferenceAsync(
string projectId,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectId);
cancellationToken.ThrowIfCancellationRequested();
IVsSolutionManager solutionManager = await _state.SolutionManager.GetValueAsync(cancellationToken);
Assumes.NotNull(solutionManager);
NuGetProject project = await GetMsBuildNuGetProjectAsync(projectId, cancellationToken);
NuGetProject newProject = await solutionManager.UpgradeProjectToPackageReferenceAsync(project);
return(await ProjectContextInfo.CreateAsync(newProject, cancellationToken));
}
private void OnProjectEvent(
EventHandler <IProjectContextInfo>?eventHandler,
string memberName,
object sender,
NuGetProjectEventArgs e)
{
if (eventHandler != null)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
IProjectContextInfo project = await ProjectContextInfo.CreateAsync(
e.NuGetProject,
CancellationToken.None);
eventHandler(sender, project);
})
.PostOnFailure(nameof(NuGetSolutionManagerService), memberName);
}
}
public async ValueTask <IReadOnlyCollection <IProjectContextInfo> > GetProjectsAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
IVsSolutionManager?solutionManager = await _sharedState.SolutionManager.GetValueAsync(cancellationToken);
Assumes.NotNull(solutionManager);
NuGetProject[] projects = (await solutionManager.GetNuGetProjectsAsync()).ToArray();
var projectContexts = new List <IProjectContextInfo>(projects.Length);
foreach (NuGetProject nugetProject in projects)
{
IProjectContextInfo?projectContext = await ProjectContextInfo.CreateAsync(nugetProject, cancellationToken);
projectContexts.Add(projectContext);
}
return(projectContexts);
}
private async Task ExecuteUpgradeNuGetProjectCommandAsync(object sender, EventArgs e)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (ShouldMEFBeInitialized())
{
await InitializeMEFAsync();
}
var project = VsMonitorSelection.GetActiveProject();
if (!await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(null, project))
{
MessageHelper.ShowWarningMessage(Resources.ProjectMigrateErrorMessage, Resources.ErrorDialogBoxTitle);
return;
}
string uniqueName = await project.GetCustomUniqueNameAsync();
// Close NuGet Package Manager if it is open for this project
IVsWindowFrame windowFrame = await FindExistingWindowFrameAsync(project);
windowFrame?.CloseFrame((uint)__FRAMECLOSE.FRAMECLOSE_SaveIfDirty);
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
NuGetProject nuGetProject = await SolutionManager.Value.GetNuGetProjectAsync(uniqueName);
IProjectContextInfo projectContextInfo = await ProjectContextInfo.CreateAsync(nuGetProject, CancellationToken.None);
using (INuGetUI uiController = await UIFactory.Value.CreateAsync(serviceBroker, projectContextInfo))
{
await uiController.UIContext.UIActionEngine.UpgradeNuGetProjectAsync(uiController, projectContextInfo);
uiController.UIContext.UserSettingsManager.PersistSettings();
}
}
public async ValueTask <IReadOnlyCollection <IProjectContextInfo> > GetProjectsWithDeprecatedDotnetFrameworkAsync(CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(_state.ResolvedActions);
cancellationToken.ThrowIfCancellationRequested();
IEnumerable <NuGetProject> affectedProjects = DotnetDeprecatedPrompt.GetAffectedProjects(_state.ResolvedActions.Values);
IEnumerable <Task <IProjectContextInfo> > tasks = affectedProjects
.Select(affectedProject => ProjectContextInfo.CreateAsync(affectedProject, cancellationToken).AsTask());
return(await Task.WhenAll(tasks));
}
private async Task <IVsWindowFrame> CreateDocWindowAsync(
Project project,
string documentName,
IVsHierarchy hier,
uint itemId)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var windowFlags =
(uint)_VSRDTFLAGS.RDT_DontAddToMRU |
(uint)_VSRDTFLAGS.RDT_DontSaveAs;
if (!await SolutionManager.Value.IsSolutionAvailableAsync())
{
throw new InvalidOperationException(Resources.SolutionIsNotSaved);
}
var uniqueName = project.GetUniqueName();
var nugetProject = await SolutionManager.Value.GetNuGetProjectAsync(uniqueName);
// If we failed to generate a cache entry in the solution manager something went wrong.
if (nugetProject == null)
{
throw new InvalidOperationException(
string.Format(Resources.ProjectHasAnInvalidNuGetConfiguration, project.Name));
}
// load packages.config. This makes sure that an exception will get thrown if there
// are problems with packages.config, such as duplicate packages. When an exception
// is thrown, an error dialog will pop up and this doc window will not be created.
_ = await nugetProject.GetInstalledPackagesAsync(CancellationToken.None);
IServiceBroker serviceBroker = await ServiceBrokerProvider.Value.GetAsync();
IProjectContextInfo contextInfo = await ProjectContextInfo.CreateAsync(nugetProject, CancellationToken.None);
INuGetUI uiController = await UIFactory.Value.CreateAsync(serviceBroker, contextInfo);
// This model takes ownership of --- and Dispose() responsibility for --- the INuGetUI instance.
var model = new PackageManagerModel(
uiController,
isSolution: false,
editorFactoryGuid: GuidList.guidNuGetEditorType);
PackageManagerControl control = await PackageManagerControl.CreateAsync(model, OutputConsoleLogger.Value);
var windowPane = new PackageManagerWindowPane(control);
var guidEditorType = GuidList.guidNuGetEditorType;
var guidCommandUI = Guid.Empty;
var caption = string.Format(
CultureInfo.CurrentCulture,
Resx.Label_NuGetWindowCaption,
project.Name);
IVsWindowFrame windowFrame;
var uiShell = await GetServiceAsync(typeof(SVsUIShell)) as IVsUIShell;
Assumes.Present(uiShell);
var ppunkDocView = IntPtr.Zero;
var ppunkDocData = IntPtr.Zero;
var hr = 0;
try
{
ppunkDocView = Marshal.GetIUnknownForObject(windowPane);
ppunkDocData = Marshal.GetIUnknownForObject(model);
hr = uiShell.CreateDocumentWindow(
windowFlags,
documentName,
(IVsUIHierarchy)hier,
itemId,
ppunkDocView,
ppunkDocData,
ref guidEditorType,
null,
ref guidCommandUI,
null,
caption,
string.Empty,
null,
out windowFrame);
if (windowFrame != null)
{
WindowFrameHelper.AddF1HelpKeyword(windowFrame, keywordValue: F1KeywordValuePmUI);
WindowFrameHelper.DisableWindowAutoReopen(windowFrame);
}
}
finally
{
if (ppunkDocView != IntPtr.Zero)
{
Marshal.Release(ppunkDocData);
}
if (ppunkDocData != IntPtr.Zero)
{
Marshal.Release(ppunkDocView);
}
}
ErrorHandler.ThrowOnFailure(hr);
return(windowFrame);
}
private async ValueTask <IVsWindowFrame> CreateToolWindowAsync(WorkspaceVisualNodeBase workspaceVisualNodeBase, IVsHierarchy hier, uint itemId)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (!Guid.TryParse(ProjectContextInfo.GetProjectGuidStringFromVslsQueryString(workspaceVisualNodeBase.VSSelectionMoniker), out Guid projectGuid))
{
throw new InvalidOperationException();
}
IVsWindowFrame windowFrame = null;
var uiShell = await _asyncServiceProvider.GetServiceAsync(typeof(SVsUIShell)) as IVsUIShell;
Assumes.Present(uiShell);
uint toolWindowId;
bool foundToolWindowId = _projectGuidToToolWindowId.TryGetValue(projectGuid.ToString(), out toolWindowId);
const uint FTW_none = 0;
if (foundToolWindowId)
{
ErrorHandler.ThrowOnFailure(
uiShell.FindToolWindowEx(
FTW_none, //grfFTW - badly-documented enum value.
typeof(PackageManagerToolWindowPane).GUID, // rguidPersistenceSlot
toolWindowId, // dwToolWindowId
out windowFrame));
if (windowFrame != null)
{
((IVsWindowFrame2)windowFrame).ActivateOwnerDockedWindow();
}
else
{
_projectGuidToToolWindowId.Remove(projectGuid.ToString());
}
}
if (windowFrame == null)
{
IProjectContextInfo projectContextInfo = await ProjectContextInfo.CreateAsync(projectGuid.ToString(), CancellationToken.None);
INuGetUI uiController = await UIFactory.Value.CreateAsync(projectContextInfo);
// This model takes ownership of --- and Dispose() responsibility for --- the INuGetUI instance.
var model = new PackageManagerModel(uiController, isSolution: false, editorFactoryGuid: GuidList.NuGetEditorType);
var control = await PackageManagerControl.CreateAsync(model, OutputConsoleLogger.Value);
var caption = string.Format(CultureInfo.CurrentCulture, Resx.Label_NuGetWindowCaption, Path.GetFileNameWithoutExtension(workspaceVisualNodeBase.NodeMoniker));
int[] pfDefaultPosition = null;
var windowPane = new PackageManagerToolWindowPane(control, projectGuid.ToString());
ErrorHandler.ThrowOnFailure(
uiShell.CreateToolWindow(
(uint)__VSCREATETOOLWIN.CTW_fInitNew,
++_maxToolWindowId, // dwToolWindowId
windowPane, // ToolWindowPane
Guid.Empty, // rclsidTool = GUID_NULL
typeof(PackageManagerToolWindowPane).GUID, // rguidPersistenceSlot
Guid.Empty, // reserved - do not use - GUID_NULL
null, // IServiceProvider
caption,
pfDefaultPosition,
out windowFrame));
_projectGuidToToolWindowId.Add(projectGuid.ToString(), _maxToolWindowId);
windowPane.Closed += WindowPane_Closed;
if (windowFrame != null)
{
WindowFrameHelper.AddF1HelpKeyword(windowFrame, keywordValue: F1KeywordValuePmUI);
WindowFrameHelper.DisableWindowAutoReopen(windowFrame);
WindowFrameHelper.DockToolWindow(windowFrame);
}
}
return(windowFrame);
}
