public override void AddFile(string path, Action <Stream> writeToStream)
{
// ensure the parent folder is created before adding file to the project
if (string.IsNullOrEmpty(path))
{
return;
}
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
await EnvDTEProjectUtility.GetProjectItemsAsync(EnvDTEProject, Path.GetDirectoryName(path), createIfNotExists: true);
base.AddFile(path, writeToStream);
});
}
public override void RemoveImport(string targetFullPath)
{
if (String.IsNullOrEmpty(targetFullPath))
{
throw new ArgumentNullException(nameof(targetFullPath), CommonResources.Argument_Cannot_Be_Null_Or_Empty);
}
ThreadHelper.JoinableTaskFactory.Run(async delegate
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var root = EnvDTEProjectUtility.GetFullPath(EnvDTEProject);
// For VS 2012 or above, the operation has to be done inside the Writer lock
string relativeTargetPath = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(root), targetFullPath);
await RemoveImportStatementForVS2013Async(relativeTargetPath);
});
}
public override void AddImport(string targetFullPath, ImportLocation location)
{
// For VS 2012 or above, the operation has to be done inside the Writer lock
if (String.IsNullOrEmpty(targetFullPath))
{
throw new ArgumentNullException(nameof(targetFullPath));
}
ThreadHelper.JoinableTaskFactory.Run(async delegate
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var root = EnvDTEProjectUtility.GetFullPath(EnvDTEProject);
string relativeTargetPath = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(root), targetFullPath);
await AddImportStatementForVS2013Async(location, relativeTargetPath);
});
}
public IEnumerable <string> GetFiles(string path, string filter, bool recursive)
{
if (recursive)
{
throw new NotSupportedException();
}
return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var childItems = await EnvDTEProjectUtility.GetChildItems(EnvDTEProject, path, filter, NuGetVSConstants.VsProjectItemKindPhysicalFile);
// Get all physical files
return from p in childItems
select p.Name;
}));
}
public static IVsHierarchy ToVsHierarchy(Project project)
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsHierarchy hierarchy;
// Get the vs solution
IVsSolution solution = ServiceLocator.GetInstance <IVsSolution>();
int hr = solution.GetProjectOfUniqueName(EnvDTEProjectUtility.GetUniqueName(project), out hierarchy);
if (hr != NuGetVSConstants.S_OK)
{
Marshal.ThrowExceptionForHR(hr);
}
return(hierarchy);
}
public async Task <IEnumerable <string> > GetReferencedProjectsAsync()
{
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
if (Project.Kind != null &&
ProjectType.IsSupportedForAddingReferences(Project.Kind))
{
return(EnvDTEProjectUtility.GetReferencedProjects(Project)
.Select(p =>
{
ThreadHelper.ThrowIfNotOnUIThread();
return p.UniqueName;
}));
}
return(Enumerable.Empty <string>());
}
public async Task <NuGetProject> GetOrCreateProjectAsync(EnvDTE.Project project, INuGetProjectContext projectContext)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectSafeName = await EnvDTEProjectUtility.GetCustomUniqueNameAsync(project);
var nuGetProject = GetNuGetProject(projectSafeName);
// if the project does not exist in the solution (this is true for new templates)
// create it manually
if (nuGetProject == null)
{
nuGetProject = CreateNuGetProject(project, projectContext);
}
return(nuGetProject);
}
public static IMSBuildNuGetProjectSystem CreateMSBuildNuGetProjectSystem(EnvDTEProject envDTEProject, INuGetProjectContext nuGetProjectContext)
{
if (envDTEProject == null)
{
throw new ArgumentNullException("project");
}
if (String.IsNullOrEmpty(envDTEProject.FullName))
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Strings.DTE_ProjectUnsupported, EnvDTEProjectUtility.GetName(envDTEProject)));
}
#if VS14
if (EnvDTEProjectUtility.SupportsINuGetProjectSystem(envDTEProject))
{
throw new InvalidOperationException("Does not support INuGetProjectSystem");
}
#endif
var guids = VsHierarchyUtility.GetProjectTypeGuids(envDTEProject);
if (guids.Contains(NuGetVSConstants.CppProjectTypeGuid)) // Got a cpp project
{
if (!EnvDTEProjectUtility.IsClr(envDTEProject))
{
return(new NativeProjectSystem(envDTEProject, nuGetProjectContext));
}
}
// Try to get a factory for the project type guid
foreach (var guid in guids)
{
IMSBuildNuGetProjectSystemThunk factory;
if (_factories.TryGetValue(guid, out factory))
{
return(factory(envDTEProject, nuGetProjectContext));
}
}
// Fall back to the default if we have no special project types
return(new VSMSBuildNuGetProjectSystem(envDTEProject, nuGetProjectContext));
}
public virtual bool ReferenceExists(string name)
{
try
{
string referenceName = name;
if (ProjectManagement.Constants.AssemblyReferencesExtensions.Contains(Path.GetExtension(name), StringComparer.OrdinalIgnoreCase))
{
// Get the reference name without extension
referenceName = Path.GetFileNameWithoutExtension(name);
}
return(EnvDTEProjectUtility.GetReferences(EnvDTEProject).Item(referenceName) != null);
}
catch
{
}
return(false);
}
// REVIEW: This might be inefficient, see what we can do with caching projects until references change
internal static IEnumerable <EnvDTEProject> GetDependentEnvDTEProjects(IDictionary <string, List <EnvDTEProject> > dependentEnvDTEProjectsDictionary, EnvDTEProject envDTEProject)
{
Debug.Assert(ThreadHelper.CheckAccess());
if (envDTEProject == null)
{
throw new ArgumentNullException(nameof(envDTEProject));
}
List <Project> dependents;
if (dependentEnvDTEProjectsDictionary.TryGetValue(EnvDTEProjectUtility.GetUniqueName(envDTEProject), out dependents))
{
return(dependents);
}
return(Enumerable.Empty <EnvDTEProject>());
}
protected override void AddFileToProject(string path)
{
if (ExcludeFile(path))
{
return;
}
// Get the project items for the folder path
string folderPath = Path.GetDirectoryName(path);
string fullPath = FileSystemUtility.GetFullPath(EnvDTEProjectUtility.GetFullPath(EnvDTEProject), path);;
ThreadHelper.Generic.Invoke(() =>
{
VCProjectHelper.AddFileToProject(EnvDTEProject.Object, fullPath, folderPath);
});
NuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName);
}
private void OnEnvDTEProjectRenamed(Project envDTEProject, string oldName)
{
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
if (!string.IsNullOrEmpty(oldName) && await IsSolutionOpenAsync() && _solutionOpenedRaised)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
await EnsureNuGetAndVsProjectAdapterCacheAsync();
if (await EnvDTEProjectUtility.IsSupportedAsync(envDTEProject))
{
RemoveVsProjectAdapterFromCache(oldName);
var vsProjectAdapter = await _vsProjectAdapterProvider.CreateAdapterForFullyLoadedProjectAsync(envDTEProject);
await AddVsProjectAdapterToCacheAsync(vsProjectAdapter);
_projectSystemCache.TryGetNuGetProject(envDTEProject.Name, out var nuGetProject);
NuGetProjectRenamed?.Invoke(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 (await EnvDTEProjectUtility.IsSolutionFolderAsync(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 await EnvDTEProjectUtility.GetSupportedChildProjectsAsync(envDTEProject))
{
RemoveVsProjectAdapterFromCache(item.FullName);
var vsProjectAdapter = await _vsProjectAdapterProvider.CreateAdapterForFullyLoadedProjectAsync(item);
if (await vsProjectAdapter.IsSupportedAsync())
{
await AddVsProjectAdapterToCacheAsync(vsProjectAdapter);
}
}
}
}
});
}
public void AddBindingRedirects()
{
var settings = ServiceLocator.GetInstanceSafe <Configuration.ISettings>();
var behavior = new BindingRedirectBehavior(settings);
if (!behavior.IsSkipped)
{
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
try
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
InitForBindingRedirects();
if (IsBindingRedirectSupported && VSSolutionManager != null)
{
await RuntimeHelpers.AddBindingRedirectsAsync(VSSolutionManager,
EnvDTEProject,
VSFrameworkMultiTargeting,
NuGetProjectContext);
}
}
catch (Exception ex)
{
var fileName = EnvDTEProjectUtility.GetFullPath(EnvDTEProject);
var level = behavior.FailOperations ?
ProjectManagement.MessageLevel.Error :
ProjectManagement.MessageLevel.Warning;
NuGetProjectContext.Log(level,
Strings.FailedToUpdateBindingRedirects,
fileName,
ex.Message);
if (behavior.FailOperations)
{
throw;
}
}
});
}
}
private void ShowWarningsForPackageReinstallation(Solution solution)
{
Debug.Assert(solution != null);
foreach (Project project in solution.Projects)
{
var nuGetProject = EnvDTEProjectUtility.GetNuGetProject(project, _solutionManager);
if (ProjectRetargetingUtility.IsProjectRetargetable(nuGetProject))
{
var packageReferencesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(nuGetProject);
if (packageReferencesToBeReinstalled.Count > 0)
{
Debug.Assert(ProjectRetargetingUtility.IsNuGetInUse(project));
var projectHierarchy = VsHierarchyUtility.ToVsHierarchy(project);
ShowRetargetingErrorTask(packageReferencesToBeReinstalled.Select(p => p.PackageIdentity.Id), projectHierarchy, TaskErrorCategory.Warning, TaskPriority.Normal);
}
}
}
}
public static Task <Dictionary <string, EnvDTE.Project> > GetPathToDTEProjectLookupAsync(EnvDTE.DTE dte)
{
var pathToProject = new Dictionary <string, EnvDTE.Project>(StringComparer.OrdinalIgnoreCase);
var supportedProjects = dte.Solution.Projects.Cast <EnvDTE.Project>();
foreach (var solutionProject in supportedProjects)
{
var solutionProjectPath = EnvDTEProjectUtility.GetFullProjectPath(solutionProject);
if (!string.IsNullOrEmpty(solutionProjectPath) &&
!pathToProject.ContainsKey(solutionProjectPath))
{
pathToProject.Add(solutionProjectPath, solutionProject);
}
}
return(Task.FromResult(pathToProject));
}
private void OnEnvDTEProjectAdded(Project envDTEProject)
{
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
if (await IsSolutionOpenAsync() &&
await EnvDTEProjectUtility.IsSupportedAsync(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));
}
});
}
public static async Task CollapseAllNodesAsync(ISolutionManager solutionManager, IDictionary <string, ISet <VsHierarchyItem> > ignoreNodes)
{
// this operation needs to execute on UI thread
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var dte = ServiceLocator.GetInstance <DTE>();
var projects = dte.Solution.Projects;
foreach (Project project in projects)
{
ISet <VsHierarchyItem> expandedNodes;
if (ignoreNodes.TryGetValue(EnvDTEProjectUtility.GetUniqueName(project), out expandedNodes)
&&
expandedNodes != null)
{
CollapseProjectHierarchyItems(project, expandedNodes);
}
}
}
public virtual void AddImport(string targetFullPath, ImportLocation location)
{
if (String.IsNullOrEmpty(targetFullPath))
{
throw new ArgumentNullException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "targetPath");
}
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
string relativeTargetPath = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(ProjectFullPath), targetFullPath);
EnvDTEProjectUtility.AddImportStatement(EnvDTEProject, relativeTargetPath, location);
EnvDTEProjectUtility.Save(EnvDTEProject);
// notify the project system of the change
UpdateImportStamp(EnvDTEProject);
});
}
public static IMSBuildNuGetProjectSystem CreateMSBuildNuGetProjectSystem(EnvDTEProject envDTEProject, INuGetProjectContext nuGetProjectContext)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (envDTEProject == null)
{
throw new ArgumentNullException(nameof(envDTEProject));
}
if (String.IsNullOrEmpty(envDTEProject.FullName))
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Strings.DTE_ProjectUnsupported, EnvDTEProjectInfoUtility.GetName(envDTEProject)));
}
if (EnvDTEProjectUtility.SupportsINuGetProjectSystem(envDTEProject))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Strings.DTE_ProjectUnsupported, typeof(IMSBuildNuGetProjectSystem).FullName));
}
var guids = VsHierarchyUtility.GetProjectTypeGuids(envDTEProject);
if (guids.Contains(VsProjectTypes.CppProjectTypeGuid)) // Got a cpp project
{
return(new NativeProjectSystem(envDTEProject, nuGetProjectContext));
}
// Try to get a factory for the project type guid
foreach (var guid in guids)
{
IMSBuildNuGetProjectSystemThunk factory;
if (_factories.TryGetValue(guid, out factory))
{
return(factory(envDTEProject, nuGetProjectContext));
}
}
// Fall back to the default if we have no special project types
return(new VSMSBuildNuGetProjectSystem(envDTEProject, nuGetProjectContext));
}
public async static Task <VsMSBuildProjectSystem> CreateMSBuildNuGetProjectSystemAsync(IVsProjectAdapter vsProjectAdapter, INuGetProjectContext nuGetProjectContext)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (vsProjectAdapter == null)
{
throw new ArgumentNullException(nameof(vsProjectAdapter));
}
if (string.IsNullOrEmpty(vsProjectAdapter.FullName))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
Strings.DTE_ProjectUnsupported, vsProjectAdapter.ProjectName));
}
if (!vsProjectAdapter.IsDeferred &&
EnvDTEProjectUtility.SupportsProjectKPackageManager(vsProjectAdapter.Project))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Strings.DTE_ProjectUnsupported, typeof(IMSBuildProjectSystem).FullName));
}
var guids = await vsProjectAdapter.GetProjectTypeGuidsAsync();
if (guids.Contains(VsProjectTypes.CppProjectTypeGuid)) // Got a cpp project
{
return(new NativeProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
// Try to get a factory for the project type guid
foreach (var guid in guids)
{
if (_factories.TryGetValue(guid, out var factory))
{
return(factory(vsProjectAdapter, nuGetProjectContext));
}
}
// Fall back to the default if we have no special project types
return(new VsMSBuildProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
public static async Task <IEnumerable <AssemblyBinding> > AddBindingRedirectsAsync(
ISolutionManager solutionManager,
EnvDTEProject envDTEProject,
AppDomain domain,
IDictionary <string, HashSet <string> > projectAssembliesCache,
IVsFrameworkMultiTargeting frameworkMultiTargeting,
INuGetProjectContext nuGetProjectContext)
{
// Run this on the UI thread since it enumerates all references
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var redirects = Enumerable.Empty <AssemblyBinding>();
var msBuildNuGetProjectSystem = GetMSBuildNuGetProjectSystem(solutionManager, envDTEProject);
// If no msBuildNuGetProjectSystem, no binding redirects. Bail
if (msBuildNuGetProjectSystem == null)
{
return(redirects);
}
// Get the full path from envDTEProject
var root = EnvDTEProjectUtility.GetFullPath(envDTEProject);
IEnumerable <string> assemblies = EnvDTEProjectUtility.GetAssemblyClosure(envDTEProject, projectAssembliesCache);
redirects = BindingRedirectResolver.GetBindingRedirects(assemblies, domain);
if (frameworkMultiTargeting != null)
{
// filter out assemblies that already exist in the target framework (CodePlex issue #3072)
FrameworkName targetFrameworkName = EnvDTEProjectUtility.GetDotNetFrameworkName(envDTEProject);
redirects = redirects.Where(p => !FrameworkAssemblyResolver.IsHigherAssemblyVersionInFramework(p.Name, p.AssemblyNewVersion, targetFrameworkName));
}
// Create a binding redirect manager over the configuration
var manager = new BindingRedirectManager(EnvDTEProjectUtility.GetConfigurationFile(envDTEProject), msBuildNuGetProjectSystem);
// Add the redirects
manager.AddBindingRedirects(redirects);
return(redirects);
}
private void EnsureNuGetAndEnvDTEProjectCache()
{
ThreadHelper.ThrowIfNotOnUIThread();
if (!_nuGetAndEnvDTEProjectCache.IsInitialized && IsSolutionOpen)
{
try
{
var supportedProjects = EnvDTESolutionUtility.GetAllEnvDTEProjects(_dte)
.Where(project => EnvDTEProjectUtility.IsSupported(project));
foreach (var project in supportedProjects)
{
try
{
AddEnvDTEProjectToCache(project);
}
catch (Exception ex)
{
// Ignore failed projects.
ActivityLog.LogWarning(
ExceptionHelper.LogEntrySource,
$"The project {project.Name} failed to initialize as a NuGet project.");
ExceptionHelper.WriteToActivityLog(ex);
}
// Consider that the cache is initialized only when there are any projects to add.
_nuGetAndEnvDTEProjectCache.IsInitialized = true;
}
SetDefaultProjectName();
}
catch
{
_nuGetAndEnvDTEProjectCache.Clear();
DefaultNuGetProjectName = null;
throw;
}
}
}
public static async TaskExpandedNodes GetAllExpandedNodesAsync(ISolutionManager solutionManager)
{
// this operation needs to execute on UI thread
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var dte = ServiceLocator.GetInstance <DTE>();
var projects = dte.Solution.Projects;
var results = new Dictionary <string, ISet <VsHierarchyItem> >(StringComparer.OrdinalIgnoreCase);
foreach (Project project in projects)
{
ICollection <VsHierarchyItem> expandedNodes =
GetExpandedProjectHierarchyItems(project);
Debug.Assert(!results.ContainsKey(EnvDTEProjectUtility.GetUniqueName(project)));
results[EnvDTEProjectUtility.GetUniqueName(project)] =
new HashSet <VsHierarchyItem>(expandedNodes);
}
return(results);
}
public override void AddReference(string referencePath)
{
string name = Path.GetFileNameWithoutExtension(referencePath);
try
{
var root = EnvDTEProjectUtility.GetFullPath(EnvDTEProject);
EnvDTEProjectUtility.GetAssemblyReferences(EnvDTEProject).AddFromFile(PathUtility.GetAbsolutePath(root, referencePath));
// Always create a refresh file. Vs does this for us in most cases, however for GACed binaries, it resorts to adding a web.config entry instead.
// This may result in deployment issues. To work around ths, we'll always attempt to add a file to the bin.
RefreshFileUtility.CreateRefreshFile(root, PathUtility.GetAbsolutePath(EnvDTEProjectUtility.GetFullPath(EnvDTEProject), referencePath), this);
NuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_AddReference, name, ProjectName);
}
catch (Exception e)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Strings.FailedToAddReference, name), e);
}
}
public override void RemoveImport(string targetPath)
{
if (String.IsNullOrEmpty(targetPath))
{
throw new ArgumentNullException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "targetPath");
}
var root = EnvDTEProjectUtility.GetFullPath(EnvDTEProject);
// For VS 2012 or above, the operation has to be done inside the Writer lock
string relativeTargetPath = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(root), targetPath);
if (VSVersionHelper.IsVisualStudio2012)
{
EnvDTEProjectUtility.DoWorkInWriterLock(EnvDTEProject, buildProject => MicrosoftBuildEvaluationProjectUtility.RemoveImportStatement(buildProject, relativeTargetPath));
EnvDTEProjectUtility.Save(EnvDTEProject);
}
else
{
RemoveImportStatementForVS2013(relativeTargetPath);
}
}
/// <summary>
/// This method should be on the UI thread. The overrides should ensure that
/// </summary>
protected virtual async Task AddFileToProjectAsync(string path)
{
Debug.Assert(ThreadHelper.CheckAccess());
if (ExcludeFile(path))
{
return;
}
// Get the project items for the folder path
string folderPath = Path.GetDirectoryName(path);
string fullPath = FileSystemUtility.GetFullPath(ProjectFullPath, path);
var container = await EnvDTEProjectUtility.GetProjectItemsAsync(EnvDTEProject, folderPath, createIfNotExists : true);
// Add the file to project or folder
AddFileToContainer(fullPath, folderPath, container);
NuGetProjectContext.Log(ProjectManagement.MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName);
}
protected virtual void AddFileToProject(string path)
{
if (ExcludeFile(path))
{
return;
}
// Get the project items for the folder path
string folderPath = Path.GetDirectoryName(path);
string fullPath = FileSystemUtility.GetFullPath(ProjectFullPath, path);
ThreadHelper.Generic.Invoke(() =>
{
EnvDTEProjectItems container = EnvDTEProjectUtility.GetProjectItems(EnvDTEProject, folderPath, createIfNotExists: true);
// Add the file to project or folder
AddFileToContainer(fullPath, folderPath, container);
});
NuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_AddedFileToProject, path, ProjectName);
}
private void EnsureNuGetAndEnvDTEProjectCache()
{
ThreadHelper.ThrowIfNotOnUIThread();
if (!_cacheInitialized && IsSolutionOpen)
{
try
{
var dte = _serviceProvider.GetDTE();
var supportedProjects = EnvDTESolutionUtility.GetAllEnvDTEProjects(dte)
.Where(project => EnvDTEProjectUtility.IsSupported(project));
foreach (var project in supportedProjects)
{
try
{
AddEnvDTEProjectToCache(project);
}
catch (Exception e)
{
// Ignore failed projects.
_logger.LogWarning($"The project {project.Name} failed to initialize as a NuGet project.");
_logger.LogError(e.ToString());
}
// Consider that the cache is initialized only when there are any projects to add.
_cacheInitialized = true;
}
SetDefaultProjectName();
}
catch
{
_projectSystemCache.Clear();
_cacheInitialized = false;
DefaultNuGetProjectName = null;
throw;
}
}
}
public virtual void RemoveFile(string path)
{
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var deleteProjectItem = await EnvDTEProjectUtility.DeleteProjectItemAsync(EnvDTEProject, path);
if (deleteProjectItem)
{
string folderPath = Path.GetDirectoryName(path);
if (!String.IsNullOrEmpty(folderPath))
{
NuGetProjectContext.Log(ProjectManagement.MessageLevel.Debug, Strings.Debug_RemovedFileFromFolder, Path.GetFileName(path), folderPath);
}
else
{
NuGetProjectContext.Log(ProjectManagement.MessageLevel.Debug, Strings.Debug_RemovedFile, Path.GetFileName(path));
}
}
});
}
private void OnEnvDTEProjectAdded(EnvDTEProject envDTEProject)
{
// This is a solution event. Should be on the UI thread
ThreadHelper.ThrowIfNotOnUIThread();
if (IsSolutionOpen &&
EnvDTEProjectUtility.IsSupported(envDTEProject) &&
!EnvDTEProjectUtility.IsParentProjectExplicitlyUnsupported(envDTEProject) &&
_solutionOpenedRaised)
{
EnsureNuGetAndEnvDTEProjectCache();
AddEnvDTEProjectToCache(envDTEProject);
NuGetProject nuGetProject;
_nuGetAndEnvDTEProjectCache.TryGetNuGetProject(envDTEProject.Name, out nuGetProject);
if (NuGetProjectAdded != null)
{
NuGetProjectAdded(this, new NuGetProjectEventArgs(nuGetProject));
}
}
}
