private async Task HandleAsync(
IProjectSubscriptionUpdate projectUpdate,
IProjectCatalogSnapshot catalogSnapshot,
RuleSource source)
{
AggregateCrossTargetProjectContext?currentAggregateContext = await _host !.GetCurrentAggregateProjectContextAsync();
if (currentAggregateContext == null || _currentProjectContext != currentAggregateContext)
{
return;
}
// Get the inner workspace project context to update for this change.
ITargetFramework?targetFrameworkToUpdate = currentAggregateContext.GetProjectFramework(projectUpdate.ProjectConfiguration);
if (targetFrameworkToUpdate == null)
{
return;
}
// Broken design time builds sometimes cause updates with no project changes and sometimes
// cause updates with a project change that has no difference.
// We handle the former case here, and the latter case is handled in the CommandLineItemHandler.
if (projectUpdate.ProjectChanges.Count == 0)
{
return;
}
if (!projectUpdate.ProjectChanges.Any(x => x.Value.Difference.AnyChanges))
{
return;
}
// Create an object to track dependency changes.
var changesBuilder = new CrossTargetDependenciesChangesBuilder();
// Give each handler a chance to register dependency changes.
foreach (Lazy <IDependenciesRuleHandler, IOrderPrecedenceMetadataView> handler in _handlers)
{
handler.Value.Handle(projectUpdate.ProjectChanges, targetFrameworkToUpdate, changesBuilder);
}
ImmutableDictionary <ITargetFramework, IDependenciesChanges>?changes = changesBuilder.TryBuildChanges();
if (changes != null)
{
// Notify subscribers of a change in dependency data
DependenciesChanged?.Invoke(
this,
new DependencySubscriptionChangedEventArgs(
currentAggregateContext.TargetFrameworks,
currentAggregateContext.ActiveTargetFramework,
catalogSnapshot,
changes));
}
// record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(targetFrameworkToUpdate, projectUpdate.ProjectChanges.Keys);
}
private void TextChanged()
{
Expr = MainParser.Parse(Source.Text);
CurrentDependencies = MainParser.GetDependencies(Expr);
DependenciesChanged?.Invoke(CurrentDependencies); // TODO send only changes
ValueChanged?.Invoke(Expr);
}
protected void OnDependenciesChanged(IDependenciesChangeDiff changes,
IProjectVersionedValue <
Tuple <IProjectSubscriptionUpdate,
IProjectCatalogSnapshot,
IProjectSharedFoldersSnapshot> > e)
{
DependenciesChanged?.Invoke(this,
new DependenciesChangedEventArgs(
this,
changes,
e.Value.Item2,
e.DataSourceVersions));
}
private async Task HandleAsync(Tuple <IProjectSubscriptionUpdate, IProjectSharedFoldersSnapshot, IProjectCatalogSnapshot> e)
{
AggregateCrossTargetProjectContext currentAggregateContext = await _host.GetCurrentAggregateProjectContext();
if (currentAggregateContext == null)
{
return;
}
IProjectSubscriptionUpdate projectUpdate = e.Item1;
IProjectSharedFoldersSnapshot sharedProjectsUpdate = e.Item2;
IProjectCatalogSnapshot catalogs = e.Item3;
// We need to process the update within a lock to ensure that we do not release this context during processing.
// TODO: Enable concurrent execution of updates themselves, i.e. two separate invocations of HandleAsync
// should be able to run concurrently.
using (await _gate.DisposableWaitAsync())
{
// Get the inner workspace project context to update for this change.
ITargetedProjectContext projectContextToUpdate = currentAggregateContext
.GetInnerProjectContext(projectUpdate.ProjectConfiguration, out bool isActiveContext);
if (projectContextToUpdate == null)
{
return;
}
var dependencyChangeContext = new DependenciesRuleChangeContext(
currentAggregateContext.ActiveProjectContext.TargetFramework,
catalogs);
ProcessSharedProjectsUpdates(sharedProjectsUpdate, projectContextToUpdate, dependencyChangeContext);
if (dependencyChangeContext.AnyChanges)
{
DependenciesChanged?.Invoke(this, new DependencySubscriptionChangedEventArgs(dependencyChangeContext));
}
}
}
private async Task HandleAsync(Tuple <IProjectSubscriptionUpdate, IProjectSharedFoldersSnapshot, IProjectCatalogSnapshot> e)
{
AggregateCrossTargetProjectContext?currentAggregateContext = await _host !.GetCurrentAggregateProjectContextAsync();
if (currentAggregateContext == null)
{
return;
}
IProjectSubscriptionUpdate projectUpdate = e.Item1;
IProjectSharedFoldersSnapshot sharedProjectsUpdate = e.Item2;
IProjectCatalogSnapshot catalogs = e.Item3;
// Get the target framework to update for this change.
ITargetFramework?targetFrameworkToUpdate = currentAggregateContext.GetProjectFramework(projectUpdate.ProjectConfiguration);
if (targetFrameworkToUpdate == null)
{
return;
}
var changesBuilder = new CrossTargetDependenciesChangesBuilder();
ProcessSharedProjectsUpdates(sharedProjectsUpdate, targetFrameworkToUpdate, changesBuilder);
ImmutableDictionary <ITargetFramework, IDependenciesChanges>?changes = changesBuilder.TryBuildChanges();
if (changes != null)
{
DependenciesChanged?.Invoke(
this,
new DependencySubscriptionChangedEventArgs(
currentAggregateContext.TargetFrameworks,
currentAggregateContext.ActiveTargetFramework,
catalogs,
changes));
}
}
protected void FireDependenciesChanged(DependenciesChangedEventArgs args)
{
DependenciesChanged?.Invoke(this, args);
}
protected override Task CompleteHandleAsync(DependenciesRuleChangeContext ruleChangeContext)
{
DependenciesChanged?.Invoke(this, new DependencySubscriptionChangedEventArgs(ruleChangeContext));
return(Task.CompletedTask);
}
private void FireDependenciesChanged()
{
DependenciesChanged?.Invoke(null, null);
}
protected override void CompleteHandle(DependenciesRuleChangeContext ruleChangeContext)
{
DependenciesChanged?.Invoke(this, new DependencySubscriptionChangedEventArgs(ruleChangeContext));
}
private void Param_DependenciesChanged(string[] deps)
{
DependenciesChanged?.Invoke(this, deps);
}
