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