internal static ProjectDependencyGraph From(Solution solution, ObjectReader reader, CancellationToken cancellationToken)
{
try
{
var graph = ReadGraph(solution, reader, cancellationToken);
if (graph == null)
{
return(null);
}
var latestProjectVersion = solution.GetLatestProjectVersion();
// check whether the loaded graph is already out of date.
if (!VersionStamp.CanReusePersistedVersion(latestProjectVersion, graph.Version))
{
return(null);
}
// make sure loaded graph is consistent with solution.
if (!CheckGraph(solution, graph.projectToProjectsItReferencesMap, cancellationToken))
{
return(null);
}
return(graph);
}
catch (Exception)
{
}
return(null);
}
internal static ProjectDependencyGraph From(Solution solution, CancellationToken cancellationToken)
{
var map = ImmutableDictionary.Create <ProjectId, ImmutableHashSet <ProjectId> >();
var reverseMap = ImmutableDictionary.Create <ProjectId, ImmutableHashSet <ProjectId> >();
foreach (var projectId in solution.ProjectIds)
{
var project = solution.GetProject(projectId);
cancellationToken.ThrowIfCancellationRequested();
var projectIds = project.ProjectReferences.Select(p => p.ProjectId);
map = map.Add(project.Id, ImmutableHashSet.CreateRange <ProjectId>(projectIds));
reverseMap = reverseMap.AddAll(projectIds, project.Id);
}
var version = solution.GetLatestProjectVersion();
return(new ProjectDependencyGraph(solution, version, map, reverseMap));
}
internal static ProjectDependencyGraph From(Solution newSolution, ProjectDependencyGraph oldGraph, CancellationToken cancellationToken)
{
var oldSolution = oldGraph.Solution;
if (oldSolution == newSolution)
{
return(oldGraph);
}
// in case old and new are incompatible just build it the hard way
if (oldSolution.Id != newSolution.Id)
{
return(From(newSolution, cancellationToken));
}
var map = oldGraph.projectToProjectsItReferencesMap;
var reverseMap = oldGraph.projectToProjectsThatReferenceItMap;
var differences = newSolution.GetChanges(oldSolution);
// remove projects that no longer occur in new solution
foreach (var project in differences.GetRemovedProjects())
{
cancellationToken.ThrowIfCancellationRequested();
ImmutableHashSet <ProjectId> referencedProjectIds;
if (oldGraph.projectToProjectsItReferencesMap.TryGetValue(project.Id, out referencedProjectIds))
{
map = map.Remove(project.Id);
reverseMap = reverseMap.RemoveAll(referencedProjectIds, project.Id);
}
}
// add projects that don't occur in old solution
foreach (var project in differences.GetAddedProjects())
{
cancellationToken.ThrowIfCancellationRequested();
var referencedProjectIds = project.ProjectReferences.Select(p => p.ProjectId);
map = map.Add(project.Id, ImmutableHashSet.CreateRange <ProjectId>(referencedProjectIds));
reverseMap = reverseMap.AddAll(referencedProjectIds, project.Id);
}
// update projects that are changed.
foreach (var projectChanges in differences.GetProjectChanges().Where(pc => pc.OldProject.AllProjectReferences != pc.NewProject.AllProjectReferences))
{
var projectId = projectChanges.ProjectId;
cancellationToken.ThrowIfCancellationRequested();
ImmutableHashSet <ProjectId> oldReferencedProjectIds;
if (oldGraph.projectToProjectsItReferencesMap.TryGetValue(projectId, out oldReferencedProjectIds))
{
map = map.Remove(projectId);
reverseMap = reverseMap.RemoveAll(oldReferencedProjectIds, projectId);
}
var newReferencedProjectIds = newSolution.GetProject(projectId).ProjectReferences.Select(p => p.ProjectId);
map = map.Add(projectId, ImmutableHashSet.CreateRange <ProjectId>(newReferencedProjectIds));
reverseMap = reverseMap.AddAll(newReferencedProjectIds, projectId);
}
var version = newSolution.GetLatestProjectVersion();
return(new ProjectDependencyGraph(newSolution, version, map, reverseMap));
}
