int IVsSolutionEventsProjectUpgrade.OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger) { NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); Debug.Assert(pHierarchy != null); var upgradedProject = VsHierarchyUtility.GetProjectFromHierarchy(pHierarchy); var upgradedNuGetProject = await EnvDTEProjectUtility.GetNuGetProjectAsync(upgradedProject, _solutionManager); if (ProjectRetargetingUtility.IsProjectRetargetable(upgradedNuGetProject)) { var packagesToBeReinstalled = await ProjectRetargetingUtility.GetPackagesToBeReinstalled(upgradedNuGetProject); if (packagesToBeReinstalled.Any()) { pLogger.LogMessage((int)__VSUL_ERRORLEVEL.VSUL_ERROR, upgradedProject.Name, upgradedProject.Name, string.Format(CultureInfo.CurrentCulture, Strings.ProjectUpgradeAndRetargetErrorMessage, string.Join(", ", packagesToBeReinstalled.Select(p => p.Id)))); } } }); return(VSConstants.S_OK); }
private static async Task <bool> IsProjectCapabilityCompliantAsync(EnvDTE.Project envDTEProject) { Debug.Assert(envDTEProject != null); var hierarchy = await envDTEProject.ToVsHierarchyAsync(); return(await VsHierarchyUtility.IsProjectCapabilityCompliantAsync(hierarchy)); }
public static void DoWorkInWriterLock(EnvDTEProject project, Action <MicrosoftBuildEvaluationProject> action) { IVsBrowseObjectContext context = project.Object as IVsBrowseObjectContext; if (context == null) { IVsHierarchy hierarchy = VsHierarchyUtility.ToVsHierarchy(project); context = hierarchy as IVsBrowseObjectContext; } if (context != null) { var service = context.UnconfiguredProject.ProjectService.Services.DirectAccessService; if (service != null) { // This has to run on Main thread, otherwise it will dead-lock (for C++ projects at least) ThreadHelper.Generic.Invoke(() => service.Write( context.UnconfiguredProject.FullPath, dwa => { MicrosoftBuildEvaluationProject buildProject = dwa.GetProject(context.UnconfiguredProject.Services.SuggestedConfiguredProject); action(buildProject); }, ProjectAccess.Read | ProjectAccess.Write) ); } } }
public ProjectJsonBuildIntegratedProjectSystem( string jsonConfigPath, string msbuildProjectFilePath, EnvDTEProject envDTEProject, string uniqueName) : base(jsonConfigPath, msbuildProjectFilePath) { _envDTEProject = envDTEProject; // set project id var projectId = VsHierarchyUtility.GetProjectId(envDTEProject); InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId); // Override the JSON TFM value from the csproj for UAP framework if (InternalMetadata.TryGetValue(NuGetProjectMetadataKeys.TargetFramework, out object targetFramework)) { var jsonTargetFramework = targetFramework as NuGetFramework; if (IsUAPFramework(jsonTargetFramework)) { var platfromMinVersion = VsHierarchyUtility.GetMSBuildProperty(VsHierarchyUtility.ToVsHierarchy(envDTEProject), EnvDTEProjectInfoUtility.TargetPlatformMinVersion); if (!string.IsNullOrEmpty(platfromMinVersion)) { // Found the TPMinV in csproj, store this as a new target framework to be replaced in project.json var newTargetFramework = new NuGetFramework(jsonTargetFramework.Framework, new Version(platfromMinVersion)); InternalMetadata[NuGetProjectMetadataKeys.TargetFramework] = newTargetFramework; } } } InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, uniqueName); }
public async Task <IVsProjectAdapter> CreateAdapterForFullyLoadedProjectAsync(IVsHierarchy hierarchy) { Assumes.Present(hierarchy); // Get services while we might be on background thread var vsSolution = await _vsSolution.GetValueAsync(); // switch to main thread and use services we know must be done on main thread. await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); var vsHierarchyItem = VsHierarchyItem.FromVsHierarchy(hierarchy); Func <IVsHierarchy, EnvDTE.Project> loadDteProject = hierarchy => VsHierarchyUtility.GetProjectFromHierarchy(hierarchy); var buildStorageProperty = vsHierarchyItem.VsHierarchy as IVsBuildPropertyStorage; var vsBuildProperties = new VsProjectBuildProperties( new Lazy <EnvDTE.Project>(() => loadDteProject(hierarchy)), buildStorageProperty, _threadingService); var fullProjectPath = VsHierarchyUtility.GetProjectPath(hierarchy); var projectNames = await ProjectNames.FromIVsSolution2(fullProjectPath, (IVsSolution2)vsSolution, hierarchy, CancellationToken.None); return(new VsProjectAdapter( vsHierarchyItem, projectNames, fullProjectPath, loadDteProject, vsBuildProperties, _threadingService)); }
int IVsTrackProjectRetargetingEvents.OnRetargetingAfterChange(string projRef, IVsHierarchy pAfterChangeHier, string fromTargetFramework, string toTargetFramework) { NuGetProject retargetedProject = null; NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); _errorListProvider.Tasks.Clear(); var project = VsHierarchyUtility.GetProjectFromHierarchy(pAfterChangeHier); retargetedProject = await EnvDTEProjectUtility.GetNuGetProjectAsync(project, _solutionManager); if (ProjectRetargetingUtility.IsProjectRetargetable(retargetedProject)) { var packagesToBeReinstalled = await ProjectRetargetingUtility.GetPackagesToBeReinstalled(retargetedProject); if (packagesToBeReinstalled.Any()) { ShowRetargetingErrorTask(packagesToBeReinstalled.Select(p => p.Id), pAfterChangeHier, TaskErrorCategory.Error, TaskPriority.High); } // NuGet/Home#4833 Baseline // Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call. #pragma warning disable CS4014 ProjectRetargetingUtility.MarkPackagesForReinstallation(retargetedProject, packagesToBeReinstalled); #pragma warning restore CS4014 } }); if (retargetedProject is LegacyPackageReferenceProject) { // trigger solution restore and don't wait for it to be complete and hold the UI thread System.Threading.Tasks.Task.Run(() => _solutionRestoreWorker.Value.ScheduleRestoreAsync(SolutionRestoreRequest.ByMenu(), CancellationToken.None)); } return(VSConstants.S_OK); }
public bool TryCreateNuGetProject(EnvDTE.Project dteProject, ProjectSystemProviderContext context, out NuGetProject result) { if (dteProject == null) { throw new ArgumentNullException(nameof(dteProject)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } ThreadHelper.ThrowIfNotOnUIThread(); result = null; var project = new EnvDTEProjectAdapter(dteProject); if (!project.IsLegacyCSProjPackageReferenceProject) { return(false); } // Lazy load the CPS enabled JoinableTaskFactory for the UI. NuGetUIThreadHelper.SetJoinableTaskFactoryFromService(ProjectServiceAccessor.Value as ProjectSystem.IProjectServiceAccessor); result = new LegacyCSProjPackageReferenceProject( project, VsHierarchyUtility.GetProjectId(dteProject)); return(true); }
public bool TryCreateNuGetProject(EnvDTE.Project dteProject, ProjectSystemProviderContext context, out NuGetProject result) { if (dteProject == null) { throw new ArgumentNullException(nameof(dteProject)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } ThreadHelper.ThrowIfNotOnUIThread(); result = null; var projectK = GetProjectKProject(dteProject); if (projectK == null) { return(false); } result = new ProjectKNuGetProject( projectK, dteProject.Name, EnvDTEProjectInfoUtility.GetCustomUniqueName(dteProject), VsHierarchyUtility.GetProjectId(dteProject)); return(true); }
public async Task <IVsProjectAdapter> CreateAdapterForDeferredProjectAsync(IVsHierarchy project) { Assumes.Present(project); await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); var vsHierarchyItem = VsHierarchyItem.FromVsHierarchy(project); var fullProjectPath = VsHierarchyUtility.GetProjectPath(project); var uniqueName = string.Empty; _vsSolution.Value.GetUniqueNameOfProject(project, out uniqueName); var projectNames = new ProjectNames( fullName: fullProjectPath, uniqueName: uniqueName, shortName: Path.GetFileNameWithoutExtension(fullProjectPath), customUniqueName: GetCustomUniqueName(uniqueName)); var workspaceBuildProperties = new WorkspaceProjectBuildProperties( fullProjectPath, _workspaceService.Value, _threadingService); var projectTypeGuid = await _workspaceService.Value.GetProjectTypeGuidAsync(fullProjectPath); return(new VsProjectAdapter( vsHierarchyItem, projectNames, fullProjectPath, projectTypeGuid, EnsureProjectIsLoaded, workspaceBuildProperties, _threadingService, _workspaceService.Value)); }
public static bool ContainsFile(EnvDTEProject envDTEProject, string path) { if (string.Equals(envDTEProject.Kind, NuGetVSConstants.WixProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, NuGetVSConstants.NemerleProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, NuGetVSConstants.FsharpProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, NuGetVSConstants.JsProjectTypeGuid, StringComparison.OrdinalIgnoreCase)) { // For Wix and Nemerle projects, IsDocumentInProject() returns not found // even though the file is in the project. So we use GetProjectItem() // instead. Nemerle is a high-level statically typed programming language for .NET platform // Note that pszMkDocument, the document moniker, passed to IsDocumentInProject(), must be a path to the file // for certain file-based project systems such as F#. And, not just a filename. For these project systems as well, // do the following EnvDTEProjectItem item = GetProjectItem(envDTEProject, path); return(item != null); } else { IVsProject vsProject = (IVsProject)VsHierarchyUtility.ToVsHierarchy(envDTEProject); if (vsProject == null) { return(false); } int pFound; uint itemId; int hr = vsProject.IsDocumentInProject(path, out pFound, new VSDOCUMENTPRIORITY[0], out itemId); return(ErrorHandler.Succeeded(hr) && pFound == 1); } }
private static async Task <bool> IncludeExistingFolderToProjectAsync(EnvDTE.Project envDTEProject, string folderRelativePath) { // Execute command to include the existing folder into project. Must do this on UI thread. await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsUIHierarchy projectHierarchy = (IVsUIHierarchy)VsHierarchyUtility.ToVsHierarchy(envDTEProject); uint itemId; int hr = projectHierarchy.ParseCanonicalName(folderRelativePath, out itemId); if (!ErrorHandler.Succeeded(hr)) { return(false); } hr = projectHierarchy.ExecCommand( itemId, ref VsMenus.guidStandardCommandSet2K, (int)VSConstants.VSStd2KCmdID.INCLUDEINPROJECT, 0, IntPtr.Zero, IntPtr.Zero); return(ErrorHandler.Succeeded(hr)); }
/// <summary> /// This method should be on the UI thread. The overrides should ensure that /// Sets NuGetPackageImportStamp to a new random guid. This is a hack to let the project system know it is out /// of date. /// The value does not matter, it just needs to change. /// </summary> protected static void UpdateImportStamp(EnvDTEProject envDTEProject) { Debug.Assert(ThreadHelper.CheckAccess()); IVsBuildPropertyStorage propStore = VsHierarchyUtility.ToVsHierarchy(envDTEProject) as IVsBuildPropertyStorage; if (propStore != null) { // <NuGetPackageImportStamp>af617720</NuGetPackageImportStamp> string stamp = Guid.NewGuid().ToString().Split('-')[0]; try { propStore.SetPropertyValue(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE, stamp); } catch (Exception ex1) { ExceptionHelper.WriteToActivityLog(ex1); } // Remove the NuGetImportStamp so that VC++ project file won't be updated with this stamp on disk, // which causes unnecessary source control pending changes. try { propStore.RemoveProperty(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE); } catch (Exception ex2) { ExceptionHelper.WriteToActivityLog(ex2); } } }
/// <summary> /// Check if the project has an unsupported project capability, such as, "SharedAssetsProject" /// </summary> public static bool HasUnsupportedProjectCapability(EnvDTE.Project envDTEProject) { Debug.Assert(ThreadHelper.CheckAccess()); var hier = VsHierarchyUtility.ToVsHierarchy(envDTEProject); return(VsHierarchyUtility.HasUnsupportedProjectCapability(hier)); }
int IVsTrackBatchRetargetingEvents.OnBatchRetargetingEnd() { NuGetProject nuGetProject = null; NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); _errorListProvider.Tasks.Clear(); if (_platformRetargetingProject != null) { try { var project = _dte.Solution.Item(_platformRetargetingProject); if (project != null) { nuGetProject = EnvDTEProjectUtility.GetNuGetProject(project, _solutionManager); if (ProjectRetargetingUtility.IsProjectRetargetable(nuGetProject)) { var frameworkName = EnvDTEProjectInfoUtility.GetTargetFrameworkString(project); if (NETCore451.Equals(frameworkName, StringComparison.OrdinalIgnoreCase) || Windows81.Equals(frameworkName, StringComparison.OrdinalIgnoreCase)) { IList <PackageIdentity> packagesToBeReinstalled = await ProjectRetargetingUtility.GetPackagesToBeReinstalled(nuGetProject); if (packagesToBeReinstalled.Count > 0) { // By asserting that NuGet is in use, we are also asserting that NuGet.VisualStudio.dll is already loaded // Hence, it is okay to call project.ToVsHierarchy() Debug.Assert(ProjectRetargetingUtility.IsNuGetInUse(project)); IVsHierarchy projectHierarchy = VsHierarchyUtility.ToVsHierarchy(project); ShowRetargetingErrorTask(packagesToBeReinstalled.Select(p => p.Id), projectHierarchy, TaskErrorCategory.Error, TaskPriority.High); } // NuGet/Home#4833 Baseline // Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call. #pragma warning disable CS4014 ProjectRetargetingUtility.MarkPackagesForReinstallation(nuGetProject, packagesToBeReinstalled); #pragma warning restore CS4014 } } } } catch (ArgumentException) { // If the solution does not contain a project named '_platformRetargetingProject', it will throw ArgumentException } _platformRetargetingProject = null; } }); #if !VS14 if (nuGetProject != null && nuGetProject is LegacyCSProjPackageReferenceProject) { // trigger solution restore and don't wait for it to be complete and hold the UI thread System.Threading.Tasks.Task.Run(() => _solutionRestoreWorker.Value.ScheduleRestoreAsync(SolutionRestoreRequest.ByMenu(), CancellationToken.None)); } #endif return(VSConstants.S_OK); }
public async Task <NuGetProject> UpdateNuGetProjectToPackageRef(NuGetProject oldProject) { #if VS14 // do nothing for VS 2015 and simply return the existing NuGetProject if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(oldProject)); } return(await Task.FromResult(oldProject)); #else if (oldProject == null) { throw new ArgumentException( Strings.Argument_Cannot_Be_Null_Or_Empty, nameof(oldProject)); } var projectName = GetNuGetProjectSafeName(oldProject); var dteProject = GetDTEProject(projectName); ProjectNames oldEnvDTEProjectName; _projectSystemCache.TryGetProjectNames(projectName, out oldEnvDTEProjectName); RemoveEnvDTEProjectFromCache(projectName); var nuGetProject = await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() => { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var settings = ServiceLocator.GetInstance <ISettings>(); var context = new ProjectSystemProviderContext( EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); return(new LegacyCSProjPackageReferenceProject( new EnvDTEProjectAdapter(dteProject), VsHierarchyUtility.GetProjectId(dteProject))); }); var added = _projectSystemCache.AddProject(oldEnvDTEProjectName, dteProject, nuGetProject); if (DefaultNuGetProjectName == null) { DefaultNuGetProjectName = projectName; } if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(nuGetProject)); } return(nuGetProject); #endif }
private void RemoveImportStatementForVS2013(string relativeTargetPath) { NuGetVS.ProjectHelper.DoWorkInWriterLock( EnvDTEProject, VsHierarchyUtility.ToVsHierarchy(EnvDTEProject), buildProject => MicrosoftBuildEvaluationProjectUtility.RemoveImportStatement(buildProject, relativeTargetPath)); // notify the project system of the change UpdateImportStamp(EnvDTEProject, true); }
private static async Task <bool> IsProjectCapabilityCompliantAsync(EnvDTE.Project envDTEProject) { Debug.Assert(envDTEProject != null); await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var hierarchy = await envDTEProject.ToVsHierarchyAsync(); return(VsHierarchyUtility.IsProjectCapabilityCompliant(hierarchy)); }
private static bool IsProjectCapabilityCompliant(EnvDTE.Project envDTEProject) { ThreadHelper.ThrowIfNotOnUIThread(); Debug.Assert(envDTEProject != null); var hierarchy = VsHierarchyUtility.ToVsHierarchy(envDTEProject); return(hierarchy.IsCapabilityMatch("AssemblyReferences + DeclaredSourceItems + UserSourceItems")); }
private static bool IsProjectCapabilityCompliant(EnvDTE.Project envDTEProject) { ThreadHelper.ThrowIfNotOnUIThread(); Debug.Assert(envDTEProject != null); var hierarchy = VsHierarchyUtility.ToVsHierarchy(envDTEProject); return(VsHierarchyUtility.IsProjectCapabilityCompliant(hierarchy)); }
private async Task RemoveImportStatementForVS2013Async(string relativeTargetPath) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await NuGetVS.ProjectHelper.DoWorkInWriterLockAsync( EnvDTEProject, VsHierarchyUtility.ToVsHierarchy(EnvDTEProject), buildProject => MicrosoftBuildEvaluationProjectUtility.RemoveImportStatement(buildProject, relativeTargetPath)); // notify the project system of the change UpdateImportStamp(EnvDTEProject); }
private async Task AddImportStatementAsync(ImportLocation location, string relativeTargetPath) { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await ProjectSystem.ProjectHelper.DoWorkInWriterLockAsync( EnvDTEProject, VsHierarchyUtility.ToVsHierarchy(EnvDTEProject), buildProject => MicrosoftBuildEvaluationProjectUtility.AddImportStatement(buildProject, relativeTargetPath, location)); // notify the project system of the change UpdateImportStamp(EnvDTEProject); }
private static bool IsProjectPackageReferenceCompatible(Project project) { var projectGuids = VsHierarchyUtility.GetProjectTypeGuids(project); if (projectGuids.Any(t => UnupgradeableProjectTypes.Contains(t))) { return(false); } // Project is supported language, and not an unsupported type return(UpgradeableProjectTypes.Contains(project.Kind) && projectGuids.All(projectTypeGuid => !SupportedProjectTypes.IsUnsupported(projectTypeGuid))); }
private static bool IsClassLibrary(EnvDTEProject envDTEProject) { if (IsWebSite(envDTEProject)) { return(false); } // Consider class libraries projects that have one project type guid and an output type of project library. var outputType = GetPropertyValue <prjOutputType>(envDTEProject, "OutputType"); return(VsHierarchyUtility.GetProjectTypeGuids(envDTEProject).Length == 1 && outputType == prjOutputType.prjOutputTypeLibrary); }
public async Task <NuGetProject> TryCreateNuGetProjectAsync( IVsProjectAdapter vsProject, ProjectProviderContext context, bool forceProjectType) { Assumes.Present(vsProject); Assumes.Present(context); ThreadHelper.ThrowIfNotOnUIThread(); // The project must be an IVsHierarchy. var hierarchy = vsProject.VsHierarchy; if (hierarchy == null) { return(null); } // Check if the project is not CPS capable or if it is CPS capable that its opt'd in PackageReferences if (!VsHierarchyUtility.IsCPSCapabilityCompliant(hierarchy) || !VsHierarchyUtility.IsProjectCapabilityCompliant(hierarchy)) { return(null); } var buildProperties = vsProject.BuildProperties; // read MSBuild property RestoreProjectStyle var restoreProjectStyle = await buildProperties.GetPropertyValueAsync(ProjectBuildProperties.RestoreProjectStyle); // check for RestoreProjectStyle property is set and if not set to PackageReference then return false if (!(string.IsNullOrEmpty(restoreProjectStyle) || restoreProjectStyle.Equals(PackageReference, StringComparison.OrdinalIgnoreCase))) { return(null); } var fullProjectPath = vsProject.FullProjectPath; var unconfiguredProject = GetUnconfiguredProject(vsProject.Project); var projectServices = new NetCoreProjectSystemServices(vsProject, await _componentModel.GetValueAsync()); return(new CpsPackageReferenceProject( vsProject.ProjectName, vsProject.CustomUniqueName, fullProjectPath, _projectSystemCache, unconfiguredProject, projectServices, vsProject.ProjectId)); }
public static async Task <bool> ContainsFileAsync(EnvDTE.Project envDTEProject, string path) { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (string.Equals(envDTEProject.Kind, VsProjectTypes.WixProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, VsProjectTypes.NemerleProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, VsProjectTypes.FsharpProjectTypeGuid, StringComparison.OrdinalIgnoreCase) || string.Equals(envDTEProject.Kind, VsProjectTypes.JsProjectTypeGuid, StringComparison.OrdinalIgnoreCase)) { // For Wix and Nemerle projects, IsDocumentInProject() returns not found // even though the file is in the project. So we use GetProjectItem() // instead. Nemerle is a high-level statically typed programming language for .NET platform // Note that pszMkDocument, the document moniker, passed to IsDocumentInProject(), must be a path to the file // for certain file-based project systems such as F#. And, not just a filename. For these project systems as well, // do the following var item = await GetProjectItemAsync(envDTEProject, path); return(item != null); } await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var hierarchy = await envDTEProject.ToVsHierarchyAsync(); var vsProject = hierarchy as IVsProject; if (vsProject == null) { return(false); } int pFound; if (VsHierarchyUtility.IsProjectCapabilityCompliant(hierarchy)) { // REVIEW: We want to revisit this after RTM - the code in this if statement should be applied to every project type. // We're checking for VSDOCUMENTPRIORITY.DP_Standard here to see if the file is included in the project. // Original check (outside of if) did not have this. var priority = new VSDOCUMENTPRIORITY[1]; var hr = vsProject.IsDocumentInProject(path, out pFound, priority, out _); return(ErrorHandler.Succeeded(hr) && pFound == 1 && priority[0] >= VSDOCUMENTPRIORITY.DP_Standard); } var hres = vsProject.IsDocumentInProject(path, out pFound, Array.Empty <VSDOCUMENTPRIORITY>(), out _); return(ErrorHandler.Succeeded(hres) && pFound == 1); }
public static async Task <bool> IsSupportedAsync(EnvDTE.Project envDTEProject) { Assumes.Present(envDTEProject); await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var hierarchy = await envDTEProject.ToVsHierarchyAsync(); if (VsHierarchyUtility.IsProjectCapabilityCompliant(hierarchy)) { return(true); } return(envDTEProject.Kind != null && ProjectType.IsSupported(envDTEProject.Kind) && !VsHierarchyUtility.HasUnsupportedProjectCapability(hierarchy)); }
/// <summary> /// Sets NuGetPackageImportStamp to a new random guid. This is a hack to let the project system know it is out of date. /// The value does not matter, it just needs to change. /// </summary> protected static void UpdateImportStamp(EnvDTEProject envDTEProject, bool isCpsProjectSystem = false) { // There is no reason to call this for pre-Dev12 project systems. if (VSVersionHelper.VsMajorVersion >= 12) { #if VS14 // Switch to UI thread to update Import Stamp for Dev14. if (isCpsProjectSystem && VSVersionHelper.IsVisualStudio2014) { try { var projectServiceAccessor = ServiceLocator.GetInstance <IProjectServiceAccessor>(); ProjectService projectService = projectServiceAccessor.GetProjectService(); IThreadHandling threadHandling = projectService.Services.ThreadingPolicy; threadHandling.SwitchToUIThread(); } catch (Exception ex) { ExceptionHelper.WriteToActivityLog(ex); } } #endif IVsBuildPropertyStorage propStore = VsHierarchyUtility.ToVsHierarchy(envDTEProject) as IVsBuildPropertyStorage; if (propStore != null) { // <NuGetPackageImportStamp>af617720</NuGetPackageImportStamp> string stamp = Guid.NewGuid().ToString().Split('-')[0]; try { int r1 = propStore.SetPropertyValue(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE, stamp); } catch (Exception ex1) { ExceptionHelper.WriteToActivityLog(ex1); } // Remove the NuGetImportStamp so that VC++ project file won't be updated with this stamp on disk, // which causes unnecessary source control pending changes. try { int r2 = propStore.RemoveProperty(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE); } catch (Exception ex2) { ExceptionHelper.WriteToActivityLog(ex2); } } } }
public Task CollapseAllNodes(ISolutionManager solutionManager) { if (solutionManager == null) { throw new ArgumentNullException(nameof(solutionManager)); } return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await VsHierarchyUtility.CollapseAllNodesAsync(solutionManager, _expandedNodes); return Task.CompletedTask; })); }
/// <summary> /// Check if the project has an unsupported project capability, such as, "SharedAssetsProject" /// </summary> public static bool HasUnsupportedProjectCapability(EnvDTE.Project envDTEProject) { Debug.Assert(ThreadHelper.CheckAccess()); var hier = VsHierarchyUtility.ToVsHierarchy(envDTEProject); foreach (var unsupportedProjectCapability in UnsupportedProjectCapabilities) { if (hier.IsCapabilityMatch(unsupportedProjectCapability)) { return(true); } } return(false); }
public ProjectJsonBuildIntegratedProjectSystem( string jsonConfigPath, string msbuildProjectFilePath, EnvDTEProject envDTEProject, string uniqueName) : base(jsonConfigPath, msbuildProjectFilePath) { _envDTEProject = envDTEProject; // set project id var projectId = VsHierarchyUtility.GetProjectId(envDTEProject); InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId); InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, uniqueName); }