public static async Task <bool> ContainsFile(EnvDTE.Project envDTEProject, string path) { ThreadHelper.ThrowIfNotOnUIThread(); 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); } var vsProject = (IVsProject)VsHierarchyUtility.ToVsHierarchy(envDTEProject); if (vsProject == null) { return(false); } int pFound; uint itemId; if (IsProjectCapabilityCompliant(envDTEProject)) { // 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 itemId); return(ErrorHandler.Succeeded(hr) && pFound == 1 && priority[0] >= VSDOCUMENTPRIORITY.DP_Standard); } var hres = vsProject.IsDocumentInProject(path, out pFound, new VSDOCUMENTPRIORITY[0], out itemId); return(ErrorHandler.Succeeded(hres) && pFound == 1); }
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 INuGetPackageManager GetProjectKProject(EnvDTE.Project dteProject) { ThreadHelper.ThrowIfNotOnUIThread(); var vsProject = VsHierarchyUtility.ToVsHierarchy(dteProject) as IVsProject; if (vsProject == null) { return(null); } IServiceProvider serviceProvider = null; vsProject.GetItemContext( (uint)VSConstants.VSITEMID.Root, out serviceProvider); if (serviceProvider == null) { return(null); } using (var sp = new ServiceProvider(serviceProvider)) { var retValue = sp.GetService(typeof(INuGetPackageManager)); if (retValue == null) { return(null); } if (!(retValue is INuGetPackageManager)) { // Workaround a bug in Dev14 prereleases where Lazy<INuGetPackageManager> was returned. var properties = retValue.GetType().GetProperties().Where(p => p.Name == "Value"); if (properties.Count() == 1) { retValue = properties.First().GetValue(retValue); } } return(retValue as INuGetPackageManager); } }
/// <summary> /// Check if the project has the SharedAssetsProject capability. This is true /// for shared projects in universal apps. /// </summary> public static bool IsSharedProject(EnvDTEProject envDTEProject) { bool isShared = false; var hier = VsHierarchyUtility.ToVsHierarchy(envDTEProject); // VSHPROPID_ProjectCapabilities is a space delimited list of capabilities (Dev11+) object capObj; if (ErrorHandler.Succeeded(hier.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID5.VSHPROPID_ProjectCapabilities, out capObj)) && capObj != null) { string cap = capObj as string; if (!String.IsNullOrEmpty(cap)) { isShared = cap.Split(' ').Any(s => StringComparer.OrdinalIgnoreCase.Equals("SharedAssetsProject", s)); } } return(isShared); }
private static bool IncludeExistingFolderToProject(EnvDTEProject envDTEProject, string folderRelativePath) { IVsUIHierarchy projectHierarchy = (IVsUIHierarchy)VsHierarchyUtility.ToVsHierarchy(envDTEProject); uint itemId; int hr = projectHierarchy.ParseCanonicalName(folderRelativePath, out itemId); if (!ErrorHandler.Succeeded(hr)) { return(false); } // Execute command to include the existing folder into project. Must do this on UI thread. hr = ThreadHelper.Generic.Invoke(() => projectHierarchy.ExecCommand( itemId, ref VsMenus.guidStandardCommandSet2K, (int)VSConstants.VSStd2KCmdID.INCLUDEINPROJECT, 0, IntPtr.Zero, IntPtr.Zero)); return(ErrorHandler.Succeeded(hr)); }
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; // The project must be an IVsHierarchy. var hierarchy = VsHierarchyUtility.ToVsHierarchy(dteProject); if (hierarchy == null) { return(false); } // Check if the project is not CPS capable or if it is CPS capable then it does not have TargetFramework(s), if so then return false if (!hierarchy.IsCapabilityMatch("CPS")) { return(false); } var buildPropertyStorage = hierarchy as IVsBuildPropertyStorage; // read MSBuild property RestoreProjectStyle, TargetFramework, and TargetFrameworks var restoreProjectStyle = VsHierarchyUtility.GetMSBuildProperty(buildPropertyStorage, RestoreProjectStyle); var targetFramework = VsHierarchyUtility.GetMSBuildProperty(buildPropertyStorage, TargetFramework); var targetFrameworks = VsHierarchyUtility.GetMSBuildProperty(buildPropertyStorage, TargetFrameworks); // check for RestoreProjectStyle property is set and if not set to PackageReference then return false if (!(string.IsNullOrEmpty(restoreProjectStyle) || restoreProjectStyle.Equals(ProjectStyle.PackageReference.ToString(), StringComparison.OrdinalIgnoreCase))) { return(false); } // check whether TargetFramework or TargetFrameworks property is set, else return false else if (string.IsNullOrEmpty(targetFramework) && string.IsNullOrEmpty(targetFrameworks)) { return(false); } // Lazy load the CPS enabled JoinableTaskFactory for the UI. NuGetUIThreadHelper.SetJoinableTaskFactoryFromService(ProjectServiceAccessor.Value as IProjectServiceAccessor); var projectNames = ProjectNames.FromDTEProject(dteProject); var fullProjectPath = EnvDTEProjectInfoUtility.GetFullProjectPath(dteProject); var unconfiguredProject = GetUnconfiguredProject(dteProject); result = new CpsPackageReferenceProject( dteProject.Name, EnvDTEProjectInfoUtility.GetCustomUniqueName(dteProject), fullProjectPath, _projectSystemCache, dteProject, unconfiguredProject, VsHierarchyUtility.GetProjectId(dteProject)); return(true); }
private static List <string> GetExcludedReferences( EnvDTEProject project, IVsEnumHierarchyItemsFactory itemsFactory) { var excludedReferences = new List <string>(); var hierarchy = VsHierarchyUtility.ToVsHierarchy(project); // Get all items in the hierarchy, this includes project references, files, and everything else. IEnumHierarchyItems items; if (ErrorHandler.Succeeded(itemsFactory.EnumHierarchyItems( hierarchy, (uint)__VSEHI.VSEHI_Leaf, (uint)VSConstants.VSITEMID.Root, out items))) { var buildPropertyStorage = (IVsBuildPropertyStorage)hierarchy; // Loop through all items uint fetched; VSITEMSELECTION[] item = new VSITEMSELECTION[1]; while (ErrorHandler.Succeeded(items.Next(1, item, out fetched)) && fetched == 1) { // Check if the item has ReferenceOutputAssembly. This will // return null for the vast majority of items. string value; if (ErrorHandler.Succeeded(buildPropertyStorage.GetItemAttribute( item[0].itemid, "ReferenceOutputAssembly", out value)) && value != null) { // We only need to go farther if the flag exists and is not true if (!string.Equals(value, bool.TrueString, StringComparison.OrdinalIgnoreCase)) { // Get the DTE Project reference for the item id. This checks for nulls incase this is // somehow not a project reference that had the ReferenceOutputAssembly flag. object childObject; if (ErrorHandler.Succeeded(hierarchy.GetProperty( item[0].itemid, (int)__VSHPROPID.VSHPROPID_ExtObject, out childObject))) { // 1. Verify that this is a project reference // 2. Check that it is valid and resolved // 3. Follow the reference to the DTE project and get the unique name var reference = childObject as Reference3; if (reference != null && reference.Resolved && reference.SourceProject != null) { var childPath = EnvDTEProjectInfoUtility .GetFullProjectPath(reference.SourceProject); excludedReferences.Add(childPath); } } } } } } return(excludedReferences); }
/// <summary> /// Check if the project has an unsupported project capability, such as, "SharedAssetsProject" /// </summary> public static bool HasUnsupportedProjectCapability(EnvDTE.Project envDTEProject) { var hier = VsHierarchyUtility.ToVsHierarchy(envDTEProject); return(VsHierarchyUtility.HasUnsupportedProjectCapability(hier)); }