private IDependenciesChanges GetChanges(ITargetFramework targetFramework) { if (!_changes.TryGetValue(targetFramework, out IDependenciesChanges change)) { change = new DependenciesChanges(); _changes = _changes.Add(targetFramework, change); } return(change); }
/// <summary> /// When some other project's snapshot changed we need to check if our snapshot has a top level /// dependency on changed project. If it does we need to refresh those top level dependencies to /// reflect changes. /// </summary> /// <param name="otherProjectSnapshot"></param> /// <param name="shouldBeResolved"> /// Specifies if top-level project dependencies resolved status. When other project just had it's dependencies /// changed, it is resolved=true (we check target's support when we add projec dependencies). However when /// other project is unloaded, we should mark top-level dependencies as unresolved. /// </param> private void OnOtherProjectDependenciesChanged(IDependenciesSnapshot otherProjectSnapshot, bool shouldBeResolved) { var projectSnapshot = SnapshotProvider.CurrentSnapshot; if (otherProjectSnapshot == null || projectSnapshot == null || projectSnapshot.Equals(otherProjectSnapshot)) { // if any of the snapshots is not provided or this is the same project - skip return; } var otherProjectPath = otherProjectSnapshot.ProjectPath; var dependencyThatNeedChange = new List <IDependency>(); foreach (var target in projectSnapshot.Targets) { foreach (var dependency in target.Value.TopLevelDependencies) { // We're only interested in project dependencies if (!StringComparers.DependencyProviderTypes.Equals(dependency.ProviderType, ProviderTypeString)) { continue; } if (!StringComparers.Paths.Equals(otherProjectPath, dependency.FullPath)) { continue; } dependencyThatNeedChange.Add(dependency); break; } } if (dependencyThatNeedChange.Count == 0) { // we don't have dependency on updated project return; } foreach (var dependency in dependencyThatNeedChange) { var model = CreateDependencyModel( ProviderType, dependency.Path, dependency.OriginalItemSpec, shouldBeResolved, dependency.Implicit, dependency.Properties); var changes = new DependenciesChanges(); // avoid unnecessary removing since, add would upgrade dependency in snapshot anyway, // but remove would require removing item from the tree instead of in-place upgrade. if (!shouldBeResolved) { changes.IncludeRemovedChange(model); } changes.IncludeAddedChange(model); FireDependenciesChanged( new DependenciesChangedEventArgs( this, dependency.TargetFramework.FullName, changes, catalogs: null, dataSourceVersions: null)); } }
/// <summary> /// When some other project's snapshot changed we need to check if our snapshot has a top level /// dependency on changed project. If it does we need to refresh those top level dependencies to /// reflect changes. /// </summary> /// <param name="thisProjectSnapshot"></param> /// <param name="otherProjectSnapshot"></param> /// <param name="shouldBeResolved"> /// Specifies if top-level project dependencies resolved status. When other project just had its dependencies /// changed, it is resolved=true (we check target's support when we add project dependencies). However when /// other project is unloaded, we should mark top-level dependencies as unresolved. /// </param> /// <param name="token"></param> private void OnOtherProjectDependenciesChanged( IDependenciesSnapshot thisProjectSnapshot, IDependenciesSnapshot otherProjectSnapshot, bool shouldBeResolved, CancellationToken token) { if (token.IsCancellationRequested || StringComparers.Paths.Equals(thisProjectSnapshot.ProjectPath, otherProjectSnapshot.ProjectPath)) { // if any of the snapshots is not provided or this is the same project - skip return; } string otherProjectPath = otherProjectSnapshot.ProjectPath; List <IDependency> dependencyThatNeedChange = null; foreach (ITargetedDependenciesSnapshot targetedDependencies in thisProjectSnapshot.Targets.Values) { foreach (IDependency dependency in targetedDependencies.TopLevelDependencies) { // We're only interested in project dependencies if (!StringComparers.DependencyProviderTypes.Equals(dependency.ProviderType, ProviderTypeString)) { continue; } if (!StringComparers.Paths.Equals(otherProjectPath, dependency.FullPath)) { continue; } if (dependencyThatNeedChange == null) { dependencyThatNeedChange = new List <IDependency>(capacity: thisProjectSnapshot.Targets.Count); } dependencyThatNeedChange.Add(dependency); break; } } if (dependencyThatNeedChange == null) { // we don't have dependency on updated project return; } foreach (IDependency dependency in dependencyThatNeedChange) { if (token.IsCancellationRequested) { return; } IDependencyModel model = CreateDependencyModel( dependency.Path, dependency.OriginalItemSpec, shouldBeResolved, dependency.Implicit, dependency.Properties); var changes = new DependenciesChanges(); // avoid unnecessary removing since, add would upgrade dependency in snapshot anyway, // but remove would require removing item from the tree instead of in-place upgrade. if (!shouldBeResolved) { changes.IncludeRemovedChange(ProviderTypeString, model.Id); } changes.IncludeAddedChange(model); FireDependenciesChanged( new DependenciesChangedEventArgs( this, dependency.TargetFramework.FullName, changes, token)); } }