public IEnumerable <Project> GetRemovedProjects()
{
foreach (var id in _oldSolution.ProjectIds)
{
if (!_newSolution.ContainsProject(id))
{
yield return(_oldSolution.GetProject(id));
}
}
}
private async Task <VersionStamp> ComputeDependentSemanticVersionAsync(Solution solution, CancellationToken cancellationToken)
{
var projectState = this.ProjectState;
var version = await projectState.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);
foreach (var dependentProjectReference in projectState.ProjectReferences)
{
cancellationToken.ThrowIfCancellationRequested();
if (solution.ContainsProject(dependentProjectReference.ProjectId))
{
var dependentProjectVersion = await solution.GetDependentSemanticVersionAsync(dependentProjectReference.ProjectId, cancellationToken).ConfigureAwait(false);
version = dependentProjectVersion.GetNewerVersion(version);
}
}
return(version);
}
private async Task<VersionStamp> ComputeDependentSemanticVersionAsync(Solution solution, CancellationToken cancellationToken)
{
var projectState = this.ProjectState;
var version = await projectState.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false);
foreach (var dependentProjectReference in projectState.ProjectReferences)
{
cancellationToken.ThrowIfCancellationRequested();
if (solution.ContainsProject(dependentProjectReference.ProjectId))
{
var dependentProjectVersion = await solution.GetDependentSemanticVersionAsync(dependentProjectReference.ProjectId, cancellationToken).ConfigureAwait(false);
version = dependentProjectVersion.GetNewerVersion(version);
}
}
return version;
}
private void ProcessProjectChange(Solution solution, ProjectId projectId)
{
this.AssertIsForeground();
// Remove anything we have associated with this project.
Dictionary<string, string> installedPackages;
_projectToInstalledPackageAndVersion.TryRemove(projectId, out installedPackages);
if (!solution.ContainsProject(projectId))
{
// Project was removed. Nothing needs to be done.
return;
}
// Project was changed in some way. Let's go find the set of installed packages for it.
var dteProject = _workspace.TryGetDTEProject(projectId);
if (dteProject == null)
{
// Don't have a DTE project for this project ID. not something we can query nuget for.
return;
}
installedPackages = new Dictionary<string, string>();
// Calling into nuget. Assume they may fail for any reason.
try
{
var installedPackageMetadata = _packageInstallerServices.GetInstalledPackages(dteProject);
installedPackages.AddRange(installedPackageMetadata.Select(m => new KeyValuePair<string, string>(m.Id, m.VersionString)));
}
catch (Exception e) when (FatalError.ReportWithoutCrash(e))
{
}
_projectToInstalledPackageAndVersion.AddOrUpdate(projectId, installedPackages, (_1, _2) => installedPackages);
}
private void ValidateSolutionAndCompilations(Solution solution)
{
foreach (var project in solution.Projects)
{
Assert.True(solution.ContainsProject(project.Id), "Solution was expected to have project " + project.Id);
Assert.Equal(project, solution.GetProject(project.Id));
// these won't always be unique in real-world but should be for these tests
Assert.Equal(project, solution.GetProjectsByName(project.Name).FirstOrDefault());
var compilation = project.GetCompilationAsync().Result;
Assert.NotNull(compilation);
// check that the options are the same
Assert.Equal(project.CompilationOptions, compilation.Options);
// check that all known metadata references are present in the compilation
foreach (var meta in project.MetadataReferences)
{
Assert.True(compilation.References.Contains(meta), "Compilation references were expected to contain " + meta);
}
// check that all project-to-project reference metadata is present in the compilation
foreach (var referenced in project.ProjectReferences)
{
if (solution.ContainsProject(referenced.ProjectId))
{
var referencedMetadata = solution.GetMetadataReferenceAsync(referenced, solution.GetProjectState(project.Id), CancellationToken.None).Result;
Assert.NotNull(referencedMetadata);
var compilationReference = referencedMetadata as CompilationReference;
if (compilationReference != null)
{
compilation.References.Single(r =>
{
var cr = r as CompilationReference;
return cr != null && cr.Compilation == compilationReference.Compilation;
});
}
}
}
// check that the syntax trees are the same
var docs = project.Documents.ToList();
var trees = compilation.SyntaxTrees.ToList();
Assert.Equal(docs.Count, trees.Count);
foreach (var doc in docs)
{
Assert.True(trees.Contains(doc.GetSyntaxTreeAsync().Result), "trees list was expected to contain the syntax tree of doc");
}
}
}
/// <summary>
/// Called when a solution is updated but when all the projects and project references
/// haven't changed. We just update to the latest solution snapshot here to not hold the old
/// solution in memory unnecessarily. Since we know that none of the relevant information
/// has actually changed, there's no need to recalculate the graph.
/// </summary>
internal ProjectDependencyGraph WithNewSolution(Solution newSolution)
{
Contract.Requires(!this.projectToProjectsItReferencesMap.Keys.Any((projectId) => !newSolution.ContainsProject(projectId)));
Contract.Requires(!this.projectToProjectsItReferencesMap.Values.Any((referencedProjectIds) =>
referencedProjectIds.Any((projectId) => !newSolution.ContainsProject(projectId))));
return(new ProjectDependencyGraph(
newSolution,
VersionStamp.Create(),
this.projectToProjectsItReferencesMap,
this.projectToProjectsThatReferenceItMap));
}
