// Get the ProjectItems for a folder path
public static async Task <EnvDTE.ProjectItems> GetProjectItemsAsync(EnvDTE.Project envDTEProject, string folderPath, bool createIfNotExists)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (String.IsNullOrEmpty(folderPath))
{
return(envDTEProject.ProjectItems);
}
// Traverse the path to get at the directory
string[] pathParts = folderPath.Split(PathSeparatorChars, StringSplitOptions.RemoveEmptyEntries);
// 'cursor' can contain a reference to either a Project instance or ProjectItem instance.
// Both types have the ProjectItems property that we want to access.
object cursor = envDTEProject;
string fullPath = EnvDTEProjectInfoUtility.GetFullPath(envDTEProject);
string folderRelativePath = String.Empty;
foreach (string part in pathParts)
{
fullPath = Path.Combine(fullPath, part);
folderRelativePath = Path.Combine(folderRelativePath, part);
cursor = await GetOrCreateFolderAsync(envDTEProject, cursor, fullPath, folderRelativePath, part, createIfNotExists);
if (cursor == null)
{
return(null);
}
}
return(GetProjectItems(cursor));
}
private static HashSet <string> GetWebsiteLocalAssemblies(EnvDTE.Project envDTEProject)
{
Debug.Assert(ThreadHelper.CheckAccess());
var assemblies = new HashSet <string>(PathComparer.Default);
AssemblyReferences references = GetAssemblyReferences(envDTEProject);
foreach (AssemblyReference reference in references)
{
// For websites only include bin assemblies
if (reference.ReferencedProject == null
&&
reference.ReferenceKind == AssemblyReferenceType.AssemblyReferenceBin
&&
File.Exists(reference.FullPath))
{
assemblies.Add(reference.FullPath);
}
}
// For website projects, we always add .refresh files that point to the corresponding binaries in packages. In the event of bin deployed assemblies that are also GACed,
// the ReferenceKind is not AssemblyReferenceBin. Consequently, we work around this by looking for any additional assembly declarations specified via .refresh files.
string envDTEProjectPath = EnvDTEProjectInfoUtility.GetFullPath(envDTEProject);
CollectionsUtility.AddRange(assemblies, RefreshFileUtility.ResolveRefreshPaths(envDTEProjectPath));
return(assemblies);
}
private async Task <bool> CheckPackagesConfigAsync()
{
return(await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var dte = _serviceProvider.GetDTE();
var projects = dte.Solution.Projects;
return projects
.OfType <EnvDTE.Project>()
.Select(p => new ProjectInfo(EnvDTEProjectInfoUtility.GetFullPath(p), p.Name))
.Any(p => p.CheckPackagesConfig());
}));
}
public override void RemoveImport(string targetFullPath)
{
if (String.IsNullOrEmpty(targetFullPath))
{
throw new ArgumentNullException(nameof(targetFullPath), CommonResources.Argument_Cannot_Be_Null_Or_Empty);
}
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var root = EnvDTEProjectInfoUtility.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 RemoveImportStatementAsync(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));
}
NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var root = EnvDTEProjectInfoUtility.GetFullPath(EnvDTEProject);
string relativeTargetPath = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(root), targetFullPath);
await AddImportStatementAsync(location, relativeTargetPath);
});
}
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 = EnvDTEProjectInfoUtility.GetFullPath(EnvDTEProject);
var level = behavior.FailOperations ?
ProjectManagement.MessageLevel.Error :
ProjectManagement.MessageLevel.Warning;
NuGetProjectContext.Log(level,
Strings.FailedToUpdateBindingRedirects,
fileName,
ex.Message);
if (behavior.FailOperations)
{
throw;
}
}
});
}
}
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 = EnvDTEProjectInfoUtility.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 = EnvDTEProjectInfoUtility.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(EnvDTEProjectInfoUtility.GetConfigurationFile(envDTEProject), msBuildNuGetProjectSystem);
// Add the redirects
manager.AddBindingRedirects(redirects);
return(redirects);
}
public bool TryCreateNuGetProject(EnvDTE.Project envDTEProject, ProjectSystemProviderContext context, out NuGetProject result)
{
if (envDTEProject == null)
{
throw new ArgumentNullException(nameof(envDTEProject));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ThreadHelper.ThrowIfNotOnUIThread();
result = null;
var msBuildNuGetProjectSystem = MSBuildNuGetProjectSystemFactory.CreateMSBuildNuGetProjectSystem(
envDTEProject,
context.ProjectContext);
var isWebSite = msBuildNuGetProjectSystem is WebSiteProjectSystem;
// Web sites cannot have project.json
if (!isWebSite)
{
// Find the project file path
var projectFilePath = EnvDTEProjectInfoUtility.GetFullProjectPath(envDTEProject);
if (!string.IsNullOrEmpty(projectFilePath))
{
var msbuildProjectFile = new FileInfo(projectFilePath);
var projectNameFromMSBuildPath = Path.GetFileNameWithoutExtension(msbuildProjectFile.Name);
// Treat projects with project.json as build integrated projects
// Search for projectName.project.json first, then project.json
// If the name cannot be determined, search only for project.json
string projectJsonPath = null;
if (string.IsNullOrEmpty(projectNameFromMSBuildPath))
{
projectJsonPath = Path.Combine(msbuildProjectFile.DirectoryName,
ProjectJsonPathUtilities.ProjectConfigFileName);
}
else
{
projectJsonPath = ProjectJsonPathUtilities.GetProjectConfigPath(msbuildProjectFile.DirectoryName,
projectNameFromMSBuildPath);
}
if (File.Exists(projectJsonPath))
{
result = new ProjectJsonBuildIntegratedProjectSystem(
projectJsonPath,
msbuildProjectFile.FullName,
envDTEProject,
EnvDTEProjectInfoUtility.GetCustomUniqueName(envDTEProject));
}
}
}
// Create a normal MSBuild project if no project.json was found
if (result == null)
{
var folderNuGetProjectFullPath = context.PackagesPathFactory();
// Project folder path is the packages config folder path
var packagesConfigFolderPath = EnvDTEProjectInfoUtility.GetFullPath(envDTEProject);
result = new VSMSBuildNuGetProject(
envDTEProject,
msBuildNuGetProjectSystem,
folderNuGetProjectFullPath,
packagesConfigFolderPath);
}
return(result != null);
}