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(
IProjectVersionedValue <Tuple <IProjectSubscriptionUpdate, IProjectCatalogSnapshot, IProjectCapabilitiesSnapshot> > e,
RuleHandlerType handlerType)
{
AggregateCrossTargetProjectContext currentAggregateContext = await _host.GetCurrentAggregateProjectContext().ConfigureAwait(false);
if (currentAggregateContext == null || _currentProjectContext != currentAggregateContext)
{
return;
}
IProjectSubscriptionUpdate update = e.Value.Item1;
IProjectCatalogSnapshot catalogs = e.Value.Item2;
IEnumerable <ICrossTargetRuleHandler <T> > handlers = Handlers.Select(h => h.Value)
.Where(h => h.SupportsHandlerType(handlerType));
// 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 themeselves, i.e. two separate invocations of HandleAsync
// should be able to run concurrently.
using (await _gate.DisposableWaitAsync().ConfigureAwait(true))
{
// Get the inner workspace project context to update for this change.
ITargetedProjectContext projectContextToUpdate = currentAggregateContext
.GetInnerProjectContext(update.ProjectConfiguration, out bool isActiveContext);
if (projectContextToUpdate == 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 (update.ProjectChanges.Count == 0)
{
if (handlerType == RuleHandlerType.DesignTimeBuild)
{
projectContextToUpdate.LastDesignTimeBuildSucceeded = false;
}
return;
}
T ruleChangeContext = CreateRuleChangeContext(
currentAggregateContext.ActiveProjectContext.TargetFramework, catalogs);
foreach (ICrossTargetRuleHandler <T> handler in handlers)
{
ImmutableDictionary <string, IProjectChangeDescription> .Builder builder = ImmutableDictionary.CreateBuilder <string, IProjectChangeDescription>(StringComparers.RuleNames);
ImmutableHashSet <string> handlerRules = handler.GetRuleNames(handlerType);
builder.AddRange(update.ProjectChanges.Where(
x => handlerRules.Contains(x.Key)));
ImmutableDictionary <string, IProjectChangeDescription> projectChanges = builder.ToImmutable();
if (handler.ReceiveUpdatesWithEmptyProjectChange ||
projectChanges.Any(x => x.Value.Difference.AnyChanges))
{
await handler.HandleAsync(e,
projectChanges,
projectContextToUpdate,
isActiveContext,
ruleChangeContext)
.ConfigureAwait(true);
}
}
await CompleteHandleAsync(ruleChangeContext).ConfigureAwait(false);
// record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(projectContextToUpdate.TargetFramework, update.ProjectChanges.Keys);
}
}
private async Task HandleAsync(
IProjectSubscriptionUpdate projectUpdate,
IProjectCatalogSnapshot catalogSnapshot,
RuleHandlerType handlerType)
{
AggregateCrossTargetProjectContext currentAggregateContext = await _host.GetCurrentAggregateProjectContext();
if (currentAggregateContext == null || _currentProjectContext != currentAggregateContext)
{
return;
}
IEnumerable <ICrossTargetRuleHandler <T> > handlers
= Handlers
.Select(h => h.Value)
.Where(h => h.SupportsHandlerType(handlerType));
ITargetedProjectContext projectContextToUpdate;
// 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.
projectContextToUpdate = currentAggregateContext
.GetInnerProjectContext(projectUpdate.ProjectConfiguration, out bool isActiveContext);
if (projectContextToUpdate == 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)
{
if (handlerType == RuleHandlerType.DesignTimeBuild)
{
projectContextToUpdate.LastDesignTimeBuildSucceeded = false;
}
return;
}
// Get the subclass-specific context that will aggregate data during the processing of rule data by handlers.
T ruleChangeContext = CreateRuleChangeContext(
currentAggregateContext.ActiveProjectContext.TargetFramework,
catalogSnapshot);
// Give each handler a chance to modify the rule change context.
foreach (ICrossTargetRuleHandler <T> handler in handlers)
{
ImmutableHashSet <string> handlerRules = handler.GetRuleNames(handlerType);
// Slice project changes to include only rules the handler claims an interest in.
var projectChanges = projectUpdate.ProjectChanges
.Where(x => handlerRules.Contains(x.Key))
.ToImmutableDictionary();
if (handler.ReceiveUpdatesWithEmptyProjectChange ||
projectChanges.Any(x => x.Value.Difference.AnyChanges))
{
// Handlers respond to rule changes in a way that's specific to the rule change context
// type (T). For example, DependencyRulesSubscriber uses DependenciesRuleChangeContext
// which holds IDependencyModel, so its ICrossTargetRuleHandler<DependenciesRuleChangeContext>
// implementations will produce IDependencyModel objects in response to rule changes.
handler.Handle(projectChanges, projectContextToUpdate.TargetFramework, ruleChangeContext);
}
}
// Notify the subclass that their rule change context object is ready for finalization.
CompleteHandle(ruleChangeContext);
}
// record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(projectContextToUpdate.TargetFramework, projectUpdate.ProjectChanges.Keys);
}