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)); } } }