public override IDependency BeforeAdd(
string projectPath,
ITargetFramework targetFramework,
IDependency dependency,
ImmutableDictionary <string, IDependency> .Builder worldBuilder,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string> projectItemSpecs,
out bool filterAnyChanges)
{
filterAnyChanges = false;
if (dependency.TopLevel &&
dependency.Resolved &&
dependency.Flags.Contains(DependencyTreeFlags.ProjectNodeFlags) &&
!dependency.Flags.Contains(DependencyTreeFlags.SharedProjectFlags))
{
ITargetedDependenciesSnapshot snapshot = GetSnapshot(dependency);
if (snapshot != null && snapshot.HasUnresolvedDependency)
{
filterAnyChanges = true;
return(dependency.ToUnresolved(ProjectReference.SchemaName));
}
}
return(dependency);
}
public override void BuildGraph(
IGraphContext graphContext,
string projectPath,
IDependency dependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
// store refreshed dependency info
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, dependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, dependency.Resolved);
var children = targetedSnapshot.GetDependencyChildren(dependency);
if (children == null)
{
return;
}
foreach (var childDependency in children)
{
if (!childDependency.Visible)
{
continue;
}
Builder.AddGraphNode(
graphContext,
projectPath,
dependencyGraphNode,
childDependency.ToViewModel(targetedSnapshot));
}
}
private bool AnyChanges(
IDependency updatedDependency,
GraphNode dependencyGraphNode,
out IReadOnlyList <DependencyNodeInfo> nodesToAdd,
out IReadOnlyList <DependencyNodeInfo> nodesToRemove,
out System.Collections.Generic.IReadOnlyCollection <IDependency> updatedChildren,
out string dependencyProjectPath)
{
ITargetedDependenciesSnapshot snapshot = GetSnapshot(updatedDependency);
if (snapshot == null)
{
nodesToAdd = default;
nodesToRemove = default;
updatedChildren = default;
dependencyProjectPath = default;
return(false);
}
dependencyProjectPath = updatedDependency.FullPath;
updatedChildren = snapshot.TopLevelDependencies;
IReadOnlyList <DependencyNodeInfo> existingChildren = GetExistingChildren(dependencyGraphNode);
IReadOnlyList <DependencyNodeInfo> updatedChildrenInfo = updatedChildren.Select(x => DependencyNodeInfo.FromDependency(x)).ToList();
return(AnyChanges(existingChildren, updatedChildrenInfo, out nodesToAdd, out nodesToRemove));
}
/// <summary>
/// Updates or creates new node
/// </summary>
private async Task <IProjectTree> CreateOrUpdateNodeAsync(
IProjectTree node,
IDependency dependency,
ITargetedDependenciesSnapshot targetedSnapshot,
IProjectCatalogSnapshot catalogs,
bool isProjectItem,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
IRule rule = null;
if (dependency.Flags.Contains(DependencyTreeFlags.SupportsRuleProperties))
{
rule = await TreeServices.GetRuleAsync(dependency, catalogs)
.ConfigureAwait(false);
}
return(CreateOrUpdateNode(
node,
dependency.ToViewModel(targetedSnapshot),
rule,
isProjectItem,
additionalFlags,
excludedFlags));
}
private bool AnyChanges(
string projectPath,
ITargetedDependenciesSnapshot targetedSnapshot,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
out IEnumerable <DependencyNodeInfo> nodesToAdd,
out IEnumerable <DependencyNodeInfo> nodesToRemove,
out IEnumerable <IDependency> updatedChildren,
out string dependencyProjectPath)
{
ITargetedDependenciesSnapshot snapshot = GetSnapshot(projectPath, updatedDependency, out dependencyProjectPath);
if (snapshot == null)
{
nodesToAdd = Enumerable.Empty <DependencyNodeInfo>();
nodesToRemove = Enumerable.Empty <DependencyNodeInfo>();
updatedChildren = Enumerable.Empty <IDependency>();
dependencyProjectPath = string.Empty;
return(false);
}
updatedChildren = snapshot.TopLevelDependencies;
IEnumerable <DependencyNodeInfo> existingChildren = GetExistingChildren(dependencyGraphNode);
IEnumerable <DependencyNodeInfo> updatedChildrenInfo = updatedChildren.Select(x => DependencyNodeInfo.FromDependency(x));
return(AnyChanges(existingChildren, updatedChildrenInfo, out nodesToAdd, out nodesToRemove));
}
public override void BuildGraph(
IGraphContext graphContext,
string projectPath,
IDependency dependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
// store refreshed dependency
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, dependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, dependency.Resolved);
ITargetedDependenciesSnapshot otherProjectTargetedSnapshot = _aggregateSnapshotProvider.GetSnapshot(dependency);
if (otherProjectTargetedSnapshot == null)
{
return;
}
foreach (IDependency childDependency in otherProjectTargetedSnapshot.TopLevelDependencies)
{
if (!childDependency.Visible)
{
continue;
}
Builder.AddGraphNode(
graphContext,
dependency.FullPath,
dependencyGraphNode,
childDependency.ToViewModel(otherProjectTargetedSnapshot));
}
}
public TargetDependencyViewModel(ITargetedDependenciesSnapshot snapshot)
{
Caption = snapshot.TargetFramework.FriendlyName;
Icon = snapshot.HasUnresolvedDependency ? ManagedImageMonikers.LibraryWarning : KnownMonikers.Library;
ExpandedIcon = Icon;
Flags = DependencyTreeFlags.TargetNodeFlags.Add($"$TFM:{snapshot.TargetFramework.Moniker}");
}
public TestableTargetedDependenciesSnapshot(
string projectPath,
ITargetFramework targetFramework,
ITargetedDependenciesSnapshot previousSnapshot = null,
IProjectCatalogSnapshot catalogs = null)
: base(projectPath, targetFramework, previousSnapshot, catalogs)
{
}
protected bool ApplyChangesInternal(
IGraphContext graphContext,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
ImmutableArray <IDependency> updatedChildren,
string nodeProjectPath,
ITargetedDependenciesSnapshot targetedSnapshot)
{
IEnumerable <DependencyNodeInfo> existingChildrenInfo = GetExistingChildren();
IEnumerable <DependencyNodeInfo> updatedChildrenInfo = updatedChildren.Select(DependencyNodeInfo.FromDependency);
var diff = new SetDiff <DependencyNodeInfo>(existingChildrenInfo, updatedChildrenInfo);
bool anyChanges = false;
foreach (DependencyNodeInfo nodeToRemove in diff.Removed)
{
anyChanges = true;
Builder.RemoveGraphNode(graphContext, nodeProjectPath, nodeToRemove.Id, dependencyGraphNode);
}
foreach (DependencyNodeInfo nodeToAdd in diff.Added)
{
if (!targetedSnapshot.DependenciesWorld.TryGetValue(nodeToAdd.Id, out IDependency dependency) ||
!dependency.Visible)
{
continue;
}
anyChanges = true;
Builder.AddGraphNode(
graphContext,
nodeProjectPath,
dependencyGraphNode,
dependency.ToViewModel(targetedSnapshot));
}
// Update the node info saved on the 'inputNode'
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, updatedDependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, updatedDependency.Resolved);
return(anyChanges);
IEnumerable <DependencyNodeInfo> GetExistingChildren()
{
foreach (GraphNode childNode in dependencyGraphNode.FindDescendants())
{
string id = childNode.GetValue <string>(DependenciesGraphSchema.DependencyIdProperty);
if (!string.IsNullOrEmpty(id))
{
bool resolved = childNode.GetValue <bool>(DependenciesGraphSchema.ResolvedProperty);
yield return(new DependencyNodeInfo(id, childNode.Label, resolved));
}
}
}
}
private async Task <IProjectTree> BuildSubTreeAsync(
IProjectTree rootNode,
ITargetedDependenciesSnapshot targetedSnapshot,
List <IDependency> dependencies,
bool isActiveTarget,
bool shouldCleanup)
{
List <IProjectTree>?currentNodes = shouldCleanup
? new List <IProjectTree>(capacity: dependencies.Count)
: null;
foreach (IDependency dependency in dependencies)
{
IProjectTree?dependencyNode = rootNode.FindChildWithCaption(dependency.Caption);
bool isNewDependencyNode = dependencyNode == null;
if (dependencyNode != null &&
dependency.Flags.Contains(DependencyTreeFlags.SupportsHierarchy))
{
if ((dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.Unresolved)) ||
(!dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.Resolved)))
{
// when transition from unresolved to resolved or vise versa - remove old node
// and re-add new one to allow GraphProvider to recalculate children
isNewDependencyNode = true;
rootNode = dependencyNode.Remove();
dependencyNode = null;
}
}
// NOTE this project system supports multiple implicit configuration dimensions (such as target framework)
// which is a concept not modelled by DTE/VSLangProj. In order to produce a sensible view of the project
// via automation, we expose only the active target framework at any given time.
//
// This is achieved by using IProjectItemTree for active target framework items, and IProjectTree for inactive
// target frameworks. CPS only creates automation objects for items with "Reference" flag if they implement
// IProjectItemTree. See SimpleItemNode.Initialize (in CPS) for details.
dependencyNode = await CreateOrUpdateNodeAsync(
dependencyNode,
dependency,
targetedSnapshot,
isProjectItem : isActiveTarget);
currentNodes?.Add(dependencyNode);
rootNode = isNewDependencyNode
? rootNode.Add(dependencyNode).Parent
: dependencyNode.Parent;
}
return(currentNodes != null // shouldCleanup
? CleanupOldNodes(rootNode, currentNodes)
: rootNode);
}
/// <summary>
/// Builds a sub tree under root: target framework or Dependencies node when there is only one target.
/// </summary>
private async Task <IProjectTree> BuildSubTreeAsync(
IProjectTree rootNode,
ITargetedDependenciesSnapshot targetedSnapshot,
IEnumerable <IDependency> dependencies,
IProjectCatalogSnapshot catalogs,
bool isActiveTarget,
bool shouldCleanup)
{
var currentNodes = new List <IProjectTree>();
foreach (IDependency dependency in dependencies)
{
IProjectTree dependencyNode = rootNode.FindNodeByCaption(dependency.Caption);
bool isNewDependencyNode = dependencyNode == null;
if (!isNewDependencyNode &&
dependency.Flags.Contains(DependencyTreeFlags.SupportsHierarchy))
{
if ((dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.UnresolvedFlags)) ||
(!dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.ResolvedFlags)))
{
// when transition from unresolved to resolved or vise versa - remove old node
// and re-add new one to allow GraphProvider to recalculate children
isNewDependencyNode = true;
rootNode = dependencyNode.Remove();
dependencyNode = null;
}
}
dependencyNode = await CreateOrUpdateNodeAsync(dependencyNode, dependency, targetedSnapshot, catalogs, isActiveTarget);
currentNodes.Add(dependencyNode);
if (isNewDependencyNode)
{
rootNode = rootNode.Add(dependencyNode).Parent;
}
else
{
rootNode = dependencyNode.Parent;
}
}
if (shouldCleanup)
{
rootNode = CleanupOldNodes(rootNode, currentNodes);
}
return(rootNode);
}
public static TargetedDependenciesSnapshot FromChanges(
string projectPath,
ITargetFramework targetFramework,
ITargetedDependenciesSnapshot previousSnapshot,
IDependenciesChanges changes,
IProjectCatalogSnapshot catalogs,
IEnumerable <IDependenciesSnapshotFilter> snapshotFilters,
out bool anyChanges)
{
var newSnapshot = new TargetedDependenciesSnapshot(projectPath, targetFramework, previousSnapshot, catalogs);
anyChanges = newSnapshot.MergeChanges(changes, snapshotFilters);
return(newSnapshot);
}
protected virtual bool AnyChanges(
string projectPath,
ITargetedDependenciesSnapshot targetedSnapshot,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
out IReadOnlyList <DependencyNodeInfo> nodesToAdd,
out IReadOnlyList <DependencyNodeInfo> nodesToRemove)
{
IReadOnlyList <DependencyNodeInfo> existingChildrenInfo = GetExistingChildren(dependencyGraphNode);
ImmutableArray <IDependency> updatedChildren = targetedSnapshot.GetDependencyChildren(updatedDependency);
IReadOnlyList <DependencyNodeInfo> updatedChildrenInfo = updatedChildren.Select(x => DependencyNodeInfo.FromDependency(x)).ToList();
return(AnyChanges(existingChildrenInfo, updatedChildrenInfo, out nodesToAdd, out nodesToRemove));
}
public virtual bool ApplyChanges(
IGraphContext graphContext,
string nodeProjectPath,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
return(ApplyChangesInternal(
graphContext,
updatedDependency,
dependencyGraphNode,
updatedChildren: targetedSnapshot.GetDependencyChildren(updatedDependency),
nodeProjectPath: nodeProjectPath,
targetedSnapshot));
}
/// <summary>
/// Returns a IDependencyViewModel for given dependency.
/// </summary>
public static IDependencyViewModel ToViewModel(this IDependency self, ITargetedDependenciesSnapshot snapshot)
{
return(new DependencyViewModel
{
Caption = self.Caption,
FilePath = self.Id,
SchemaName = self.SchemaName,
SchemaItemType = self.SchemaItemType,
Priority = self.Priority,
Icon = self.IsOrHasUnresolvedDependency(snapshot) ? self.UnresolvedIcon : self.Icon,
ExpandedIcon = self.IsOrHasUnresolvedDependency(snapshot) ? self.UnresolvedExpandedIcon : self.ExpandedIcon,
Properties = self.Properties,
Flags = self.Flags,
OriginalModel = self
});
}
public virtual bool TrackChanges(
IGraphContext graphContext,
string projectPath,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
if (!AnyChanges(projectPath,
targetedSnapshot,
updatedDependency,
dependencyGraphNode,
out IEnumerable <DependencyNodeInfo> nodesToAdd,
out IEnumerable <DependencyNodeInfo> nodesToRemove,
out string dependencyProjectPath))
{
return(false);
}
foreach (var nodeToRemove in nodesToRemove)
{
Builder.RemoveGraphNode(graphContext, projectPath, nodeToRemove.Id, dependencyGraphNode);
}
foreach (var nodeToAdd in nodesToAdd)
{
if (!targetedSnapshot.DependenciesWorld.TryGetValue(nodeToAdd.Id, out IDependency dependency) ||
dependency == null ||
!dependency.Visible)
{
continue;
}
Builder.AddGraphNode(
graphContext,
projectPath,
dependencyGraphNode,
dependency.ToViewModel(targetedSnapshot));
}
// Update the node info saved on the 'inputNode'
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, updatedDependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, updatedDependency.Resolved);
return(true);
}
public override bool TrackChanges(
IGraphContext graphContext,
string projectPath,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
if (!AnyChanges(projectPath,
targetedSnapshot,
updatedDependency,
dependencyGraphNode,
out IEnumerable <DependencyNodeInfo> nodesToAdd,
out IEnumerable <DependencyNodeInfo> nodesToRemove,
out IEnumerable <IDependency> updatedChildren,
out string dependencyProjectPath))
{
return(false);
}
foreach (DependencyNodeInfo nodeToRemove in nodesToRemove)
{
Builder.RemoveGraphNode(graphContext, dependencyProjectPath, nodeToRemove.Id, dependencyGraphNode);
}
foreach (DependencyNodeInfo nodeToAdd in nodesToAdd)
{
IDependency dependency = updatedChildren.FirstOrDefault(x => x.Id.Equals(nodeToAdd.Id));
if (dependency == null || !dependency.Visible)
{
continue;
}
Builder.AddGraphNode(
graphContext,
dependencyProjectPath,
dependencyGraphNode,
dependency.ToViewModel(targetedSnapshot));
}
// Update the node info saved on the 'inputNode'
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, updatedDependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, updatedDependency.Resolved);
return(true);
}
protected TargetedDependenciesSnapshot(string projectPath,
ITargetFramework targetFramework,
ITargetedDependenciesSnapshot previousSnapshot = null,
IProjectCatalogSnapshot catalogs = null)
{
Requires.NotNullOrEmpty(projectPath, nameof(projectPath));
Requires.NotNull(targetFramework, nameof(targetFramework));
ProjectPath = projectPath;
TargetFramework = targetFramework;
Catalogs = catalogs;
if (previousSnapshot != null)
{
TopLevelDependencies = previousSnapshot.TopLevelDependencies;
DependenciesWorld = previousSnapshot.DependenciesWorld;
}
}
protected virtual bool AnyChanges(
string projectPath,
ITargetedDependenciesSnapshot targetedSnapshot,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
out IEnumerable <DependencyNodeInfo> nodesToAdd,
out IEnumerable <DependencyNodeInfo> nodesToRemove,
out string dependencyProjectPath)
{
dependencyProjectPath = projectPath;
IEnumerable <DependencyNodeInfo> existingChildrenInfo = GetExistingChildren(dependencyGraphNode);
IEnumerable <IDependency> updatedChildren = targetedSnapshot.GetDependencyChildren(updatedDependency)
?? Enumerable.Empty <IDependency>();
IEnumerable <DependencyNodeInfo> updatedChildrenInfo = updatedChildren.Select(x => DependencyNodeInfo.FromDependency(x));
return(AnyChanges(existingChildrenInfo, updatedChildrenInfo, out nodesToAdd, out nodesToRemove));
}
private HashSet <IDependency> GetMatchingResultsForDependency(
IDependency rootDependency,
ITargetedDependenciesSnapshot snapshot,
HashSet <IDependency> flatMatchingDependencies,
Dictionary <string, HashSet <IDependency> > cachedPositiveResults)
{
var matchingNodes = new HashSet <IDependency>();
foreach (var childDependency in rootDependency.DependencyIDs)
{
if (!snapshot.DependenciesWorld
.TryGetValue(childDependency, out IDependency childDependencyMetadata))
{
continue;
}
if (flatMatchingDependencies.Contains(childDependencyMetadata))
{
matchingNodes.Add(childDependencyMetadata);
}
if (cachedPositiveResults.TryGetValue(childDependency, out HashSet <IDependency> cachedResults))
{
matchingNodes.AddRange(cachedResults);
continue;
}
var children = GetMatchingResultsForDependency(
childDependencyMetadata,
snapshot,
flatMatchingDependencies,
cachedPositiveResults);
cachedPositiveResults[childDependency] = children;
if (children.Count > 0)
{
matchingNodes.AddRange(children);
}
}
return(matchingNodes);
}
/// <summary>
/// Builds a sub tree under root: target framework or Dependencies node when there is only one target.
/// </summary>
private async Task <IProjectTree> BuildSubTreeAsync(
IProjectTree rootNode,
ITargetedDependenciesSnapshot targetedSnapshot,
List <IDependency> dependencies,
bool isActiveTarget,
bool shouldCleanup)
{
List <IProjectTree> currentNodes = shouldCleanup
? new List <IProjectTree>(capacity: dependencies.Count)
: null;
foreach (IDependency dependency in dependencies)
{
IProjectTree dependencyNode = rootNode.FindChildWithCaption(dependency.Caption);
bool isNewDependencyNode = dependencyNode == null;
if (!isNewDependencyNode &&
dependency.Flags.Contains(DependencyTreeFlags.SupportsHierarchy))
{
if ((dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.UnresolvedFlags)) ||
(!dependency.Resolved && dependencyNode.Flags.Contains(DependencyTreeFlags.ResolvedFlags)))
{
// when transition from unresolved to resolved or vise versa - remove old node
// and re-add new one to allow GraphProvider to recalculate children
isNewDependencyNode = true;
rootNode = dependencyNode.Remove();
dependencyNode = null;
}
}
dependencyNode = await CreateOrUpdateNodeAsync(dependencyNode, dependency, targetedSnapshot, isActiveTarget);
currentNodes?.Add(dependencyNode);
rootNode = isNewDependencyNode
? rootNode.Add(dependencyNode).Parent
: dependencyNode.Parent;
}
return(shouldCleanup
? CleanupOldNodes(rootNode, currentNodes)
: rootNode);
}
private async Task <IProjectTree> CreateOrUpdateNodeAsync(
IProjectTree?node,
IDependency dependency,
ITargetedDependenciesSnapshot targetedSnapshot,
bool isProjectItem,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
IRule?browseObjectProperties = dependency.Flags.Contains(DependencyTreeFlags.SupportsRuleProperties)
? await _treeServices.GetBrowseObjectRuleAsync(dependency, targetedSnapshot.Catalogs)
: null;
return(CreateOrUpdateNode(
node,
dependency.ToViewModel(targetedSnapshot),
browseObjectProperties,
isProjectItem,
additionalFlags,
excludedFlags));
}
public override void BeforeAddOrUpdate(
string projectPath,
ITargetFramework targetFramework,
IDependency dependency,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string> projectItemSpecs,
IAddDependencyContext context)
{
if (dependency.TopLevel &&
dependency.Resolved &&
dependency.Flags.Contains(DependencyTreeFlags.ProjectNodeFlags) &&
!dependency.Flags.Contains(DependencyTreeFlags.SharedProjectFlags))
{
ITargetedDependenciesSnapshot snapshot = GetSnapshot(dependency);
if (snapshot != null && snapshot.HasUnresolvedDependency)
{
context.Accept(dependency.ToUnresolved(ProjectReference.SchemaName));
return;
}
}
context.Accept(dependency);
}
public override bool ApplyChanges(
IGraphContext graphContext,
string nodeProjectPath,
IDependency updatedDependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
ITargetedDependenciesSnapshot referencedProjectSnapshot = _aggregateSnapshotProvider.GetSnapshot(updatedDependency);
if (referencedProjectSnapshot == null)
{
return(false);
}
return(ApplyChangesInternal(
graphContext,
updatedDependency,
dependencyGraphNode,
// Project references list all top level dependencies as direct children
updatedChildren: referencedProjectSnapshot.TopLevelDependencies,
// Pass the path of the referenced project
nodeProjectPath: updatedDependency.FullPath,
targetedSnapshot: referencedProjectSnapshot));
}
/// <summary>
/// Returns a IDependencyViewModel for given dependency.
/// </summary>
public static IDependencyViewModel ToViewModel(this IDependency self, ITargetedDependenciesSnapshot snapshot)
{
return(new DependencyViewModel(self, hasUnresolvedDependency: self.IsOrHasUnresolvedDependency(snapshot)));
}
public override void BuildGraph(
IGraphContext graphContext,
string projectPath,
IDependency dependency,
GraphNode dependencyGraphNode,
ITargetedDependenciesSnapshot targetedSnapshot)
{
// store refreshed dependency info
dependencyGraphNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, dependency.Id);
dependencyGraphNode.SetValue(DependenciesGraphSchema.ResolvedProperty, dependency.Resolved);
IEnumerable <IDependency> children = targetedSnapshot.GetDependencyChildren(dependency);
if (children == null)
{
return;
}
var regularChildren = new List <IDependency>();
var fxAssembliesChildren = new List <IDependency>();
foreach (IDependency childDependency in children)
{
if (!childDependency.Visible)
{
continue;
}
if (childDependency.Flags.Contains(DependencyTreeFlags.FxAssemblyProjectFlags))
{
fxAssembliesChildren.Add(childDependency);
}
else
{
regularChildren.Add(childDependency);
}
}
bool isFxAssembliesFolder = dependencyGraphNode.GetValue <bool>(DependenciesGraphSchema.IsFrameworkAssemblyFolderProperty);
if (isFxAssembliesFolder)
{
foreach (IDependency fxAssembly in fxAssembliesChildren)
{
Builder.AddGraphNode(
graphContext,
projectPath,
dependencyGraphNode,
fxAssembly.ToViewModel(targetedSnapshot));
}
}
else
{
foreach (IDependency childDependency in regularChildren)
{
Builder.AddGraphNode(
graphContext,
projectPath,
dependencyGraphNode,
childDependency.ToViewModel(targetedSnapshot));
}
if (fxAssembliesChildren.Count > 0)
{
var fxAssembliesViewModel = new PackageFrameworkAssembliesViewModel();
GraphNode fxAssembliesNode = Builder.AddGraphNode(graphContext, projectPath, dependencyGraphNode, fxAssembliesViewModel);
fxAssembliesNode.SetValue(DgmlNodeProperties.ContainsChildren, true);
fxAssembliesNode.SetValue(DependenciesGraphSchema.IsFrameworkAssemblyFolderProperty, true);
fxAssembliesNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, dependency.Id);
fxAssembliesNode.SetValue(DependenciesGraphSchema.ResolvedProperty, dependency.Resolved);
}
}
}
public override bool HasChildren(IDependency dependency)
{
ITargetedDependenciesSnapshot targetedSnapshot = _aggregateSnapshotProvider.GetSnapshot(dependency);
return(targetedSnapshot?.TopLevelDependencies.Length != 0);
}
public override bool HasChildren(string projectPath, IDependency dependency)
{
ITargetedDependenciesSnapshot targetedSnapshot = GetSnapshot(projectPath, dependency, out string dependencyProjectPath);
return(targetedSnapshot?.TopLevelDependencies.Count > 0);
}
/// <summary>
/// Returns true if this reference itself is unresolved or it has at least
/// one unresolved reference somewhere in the dependency chain.
/// </summary>
public static bool IsOrHasUnresolvedDependency(this IDependency self, ITargetedDependenciesSnapshot snapshot)
{
return(!self.Resolved || self.HasUnresolvedDependency(snapshot));
}
/// <summary>
/// Specifies if there is unresolved child somewhere in the dependency graph
/// </summary>
public static bool HasUnresolvedDependency(this IDependency self, ITargetedDependenciesSnapshot snapshot)
{
return(snapshot.CheckForUnresolvedDependencies(self));
}
