private void OnEnvDTEProjectAdded(EnvDTE.Project envDTEProject)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (IsSolutionOpen &&
EnvDTEProjectUtility.IsSupported(envDTEProject) &&
!EnvDTEProjectUtility.IsParentProjectExplicitlyUnsupported(envDTEProject) &&
_solutionOpenedRaised)
{
await EnsureNuGetAndVsProjectAdapterCacheAsync();
var vsProjectAdapter = await _vsProjectAdapterProvider.CreateAdapterForFullyLoadedProjectAsync(envDTEProject);
await AddVsProjectAdapterToCacheAsync(vsProjectAdapter);
NuGetProject nuGetProject;
_projectSystemCache.TryGetNuGetProject(envDTEProject.Name, out nuGetProject);
NuGetProjectAdded?.Invoke(this, new NuGetProjectEventArgs(nuGetProject));
}
});
}
private void AddEnvDTEProjectToCache(EnvDTEProject envDTEProject)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (!EnvDTEProjectUtility.IsSupported(envDTEProject))
{
return;
}
EnvDTEProjectName oldEnvDTEProjectName;
_nuGetAndEnvDTEProjectCache.TryGetProjectNameByShortName(EnvDTEProjectUtility.GetName(envDTEProject), out oldEnvDTEProjectName);
// Create the NuGet project first. If this throws we bail out and do not change the cache.
var nuGetProject = GetProjectFactory().CreateNuGetProject(envDTEProject);
// Then create the project name from the project.
var newEnvDTEProjectName = new EnvDTEProjectName(envDTEProject);
// Finally, try to add the project to the cache.
var added = _nuGetAndEnvDTEProjectCache.AddProject(newEnvDTEProjectName, envDTEProject, nuGetProject);
if (added)
{
// Emit project specific telemetry as we are adding the project to the cache.
// This ensures we do not emit the events over and over while the solution is
// open.
NuGetProjectTelemetryService.Instance.EmitNuGetProject(envDTEProject, nuGetProject);
}
if (string.IsNullOrEmpty(DefaultNuGetProjectName) ||
newEnvDTEProjectName.ShortName.Equals(DefaultNuGetProjectName, StringComparison.OrdinalIgnoreCase))
{
DefaultNuGetProjectName = oldEnvDTEProjectName != null ?
oldEnvDTEProjectName.CustomUniqueName :
newEnvDTEProjectName.ShortName;
}
}
private void OnEnvDTEProjectRenamed(EnvDTEProject envDTEProject, string oldName)
{
// This is a solution event. Should be on the UI thread
ThreadHelper.ThrowIfNotOnUIThread();
if (!String.IsNullOrEmpty(oldName) && IsSolutionOpen && _solutionOpenedRaised)
{
EnsureNuGetAndEnvDTEProjectCache();
if (EnvDTEProjectUtility.IsSupported(envDTEProject))
{
RemoveEnvDTEProjectFromCache(oldName);
AddEnvDTEProjectToCache(envDTEProject);
NuGetProject nuGetProject;
_nuGetAndEnvDTEProjectCache.TryGetNuGetProject(envDTEProject.Name, out nuGetProject);
if (NuGetProjectRenamed != null)
{
NuGetProjectRenamed(this, new NuGetProjectEventArgs(nuGetProject));
}
// VSSolutionManager susbscribes to this Event, in order to update the caption on the DocWindow Tab.
// This needs to fire after NugetProjectRenamed so that PackageManagerModel has been updated with
// the right project context.
AfterNuGetProjectRenamed?.Invoke(this, new NuGetProjectEventArgs(nuGetProject));
}
else if (EnvDTEProjectUtility.IsSolutionFolder(envDTEProject))
{
// In the case where a solution directory was changed, project FullNames are unchanged.
// We only need to invalidate the projects under the current tree so as to sync the CustomUniqueNames.
foreach (var item in EnvDTEProjectUtility.GetSupportedChildProjects(envDTEProject))
{
RemoveEnvDTEProjectFromCache(item.FullName);
AddEnvDTEProjectToCache(item);
}
}
}
}
private void AddEnvDTEProjectToCache(EnvDTEProject envDTEProject)
{
Debug.Assert(ThreadHelper.CheckAccess());
if (!EnvDTEProjectUtility.IsSupported(envDTEProject))
{
return;
}
EnvDTEProjectName oldEnvDTEProjectName;
_nuGetAndEnvDTEProjectCache.TryGetProjectNameByShortName(EnvDTEProjectUtility.GetName(envDTEProject), out oldEnvDTEProjectName);
var newEnvDTEProjectName = _nuGetAndEnvDTEProjectCache.AddProject(envDTEProject, GetProjectFactory());
if (string.IsNullOrEmpty(DefaultNuGetProjectName) ||
newEnvDTEProjectName.ShortName.Equals(DefaultNuGetProjectName, StringComparison.OrdinalIgnoreCase))
{
DefaultNuGetProjectName = oldEnvDTEProjectName != null ?
oldEnvDTEProjectName.CustomUniqueName :
newEnvDTEProjectName.ShortName;
}
}
private void EnsureNuGetAndEnvDTEProjectCache()
{
if (!_nuGetAndEnvDTEProjectCache.IsInitialized && IsSolutionOpen)
{
var factory = GetProjectFactory();
try
{
var supportedProjects = EnvDTESolutionUtility.GetAllEnvDTEProjects(_dte.Solution)
.Where(project => EnvDTEProjectUtility.IsSupported(project));
_nuGetAndEnvDTEProjectCache.Initialize(supportedProjects, factory);
SetDefaultProjectName();
}
catch
{
_nuGetAndEnvDTEProjectCache.Clear();
DefaultNuGetProjectName = null;
throw;
}
}
}
public static async Task <IEnumerable <EnvDTE.Project> > GetAllEnvDTEProjectsAsync(EnvDTE.DTE dte)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var envDTESolution = dte.Solution;
if (envDTESolution == null ||
!envDTESolution.IsOpen)
{
return(Enumerable.Empty <EnvDTE.Project>());
}
var envDTEProjects = new Stack <EnvDTE.Project>();
foreach (EnvDTE.Project envDTEProject in envDTESolution.Projects)
{
if (!EnvDTEProjectUtility.IsExplicitlyUnsupported(envDTEProject))
{
envDTEProjects.Push(envDTEProject);
}
}
var resultantEnvDTEProjects = new List <EnvDTE.Project>();
while (envDTEProjects.Any())
{
var envDTEProject = envDTEProjects.Pop();
if (EnvDTEProjectUtility.IsSupported(envDTEProject))
{
resultantEnvDTEProjects.Add(envDTEProject);
}
else if (EnvDTEProjectUtility.IsExplicitlyUnsupported(envDTEProject))
{
// do not drill down further if this project is explicitly unsupported, e.g. LightSwitch projects
continue;
}
EnvDTE.ProjectItems envDTEProjectItems = null;
try
{
// bug 1138: Oracle Database Project doesn't implement the ProjectItems property
envDTEProjectItems = envDTEProject.ProjectItems;
}
catch (NotImplementedException)
{
continue;
}
// ProjectItems property can be null if the project is unloaded
if (envDTEProjectItems != null)
{
foreach (EnvDTE.ProjectItem envDTEProjectItem in envDTEProjectItems)
{
try
{
if (envDTEProjectItem.SubProject != null)
{
envDTEProjects.Push(envDTEProjectItem.SubProject);
}
}
catch (NotImplementedException)
{
// Some project system don't implement the SubProject property,
// just ignore those
}
}
}
}
return(resultantEnvDTEProjects);
}
public static async Task <bool> IsNuGetProjectUpgradeableAsync(NuGetProject nuGetProject, Project envDTEProject = null)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (nuGetProject == null && envDTEProject == null)
{
return(false);
}
if (nuGetProject == null)
{
var solutionManager = ServiceLocator.GetInstance <IVsSolutionManager>();
var projectSafeName = await EnvDTEProjectInfoUtility.GetCustomUniqueNameAsync(envDTEProject);
nuGetProject = await solutionManager.GetNuGetProjectAsync(projectSafeName);
if (nuGetProject == null)
{
return(false);
}
}
// check if current project is packages.config based or not
var msBuildNuGetProject = nuGetProject as MSBuildNuGetProject;
if (msBuildNuGetProject == null || !msBuildNuGetProject.PackagesConfigNuGetProject.PackagesConfigExists())
{
return(false);
}
// this further check if current project system supports VSProject4 or not which is essential to skip
// projects like c++ which currently doesn't support VSProject4 implementation for PackageReference
if (!msBuildNuGetProject.ProjectServices.Capabilities.SupportsPackageReferences)
{
return(false);
}
if (envDTEProject == null)
{
var vsmsBuildNuGetProjectSystem =
msBuildNuGetProject.ProjectSystem as VsMSBuildProjectSystem;
if (vsmsBuildNuGetProjectSystem == null)
{
return(false);
}
envDTEProject = vsmsBuildNuGetProjectSystem.VsProjectAdapter.Project;
}
if (!EnvDTEProjectUtility.IsSupported(envDTEProject))
{
return(false);
}
var projectGuids = VsHierarchyUtility.GetProjectTypeGuids(envDTEProject);
if (projectGuids.Any(t => UnupgradeableProjectTypes.Contains(t)))
{
return(false);
}
// Project is supported language, and not an unsupported type
return(UpgradeableProjectTypes.Contains(envDTEProject.Kind) &&
projectGuids.All(projectTypeGuid => !SupportedProjectTypes.IsUnsupported(projectTypeGuid)));
}
/// <summary>
/// Determines if NuGet is used in the project. Currently, it is determined by checking if packages.config is part of the project
/// </summary>
/// <param name="project">The project which is checked to see if NuGet is used in it</param>
public static bool IsNuGetInUse(Project project)
{
return(EnvDTEProjectUtility.IsSupported(project) && File.Exists(project.GetPackagesConfigFullPath()));
}
/// <summary>
/// Get the list of all supported projects in the current solution. This method
/// recursively iterates through all projects.
/// </summary>
public static IEnumerable <EnvDTEProject> GetAllEnvDTEProjects(EnvDTESolution envDTESolution)
{
if (envDTESolution == null || !envDTESolution.IsOpen)
{
yield break;
}
var envDTEProjects = new Stack <EnvDTEProject>();
foreach (EnvDTEProject envDTEProject in envDTESolution.Projects)
{
if (!EnvDTEProjectUtility.IsExplicitlyUnsupported(envDTEProject))
{
envDTEProjects.Push(envDTEProject);
}
}
while (envDTEProjects.Any())
{
EnvDTEProject envDTEProject = envDTEProjects.Pop();
if (EnvDTEProjectUtility.IsSupported(envDTEProject))
{
yield return(envDTEProject);
}
else if (EnvDTEProjectUtility.IsExplicitlyUnsupported(envDTEProject))
{
// do not drill down further if this project is explicitly unsupported, e.g. LightSwitch projects
continue;
}
EnvDTEProjectItems envDTEProjectItems = null;
try
{
// bug 1138: Oracle Database Project doesn't implement the ProjectItems property
envDTEProjectItems = envDTEProject.ProjectItems;
}
catch (NotImplementedException)
{
continue;
}
// ProjectItems property can be null if the project is unloaded
if (envDTEProjectItems != null)
{
foreach (EnvDTEProjectItem envDTEProjectItem in envDTEProjectItems)
{
try
{
if (envDTEProjectItem.SubProject != null)
{
envDTEProjects.Push(envDTEProjectItem.SubProject);
}
}
catch (NotImplementedException)
{
// Some project system don't implement the SubProject property,
// just ignore those
continue;
}
}
}
}
}
