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