private async Task UpdateProjectContextAndSubscriptionsAsync()
{
AggregateCrossTargetProjectContext previousProjectContext = await ExecuteWithinLockAsync(() => _currentAggregateProjectContext);
AggregateCrossTargetProjectContext newProjectContext = await UpdateProjectContextAsync();
if (previousProjectContext != newProjectContext)
{
// Dispose existing subscriptions.
DisposeAndClearSubscriptions();
// Add subscriptions for the configured projects in the new project context.
await AddSubscriptionsAsync(newProjectContext);
}
}
/// <summary>
/// Ensures that <see cref="_currentAggregateProjectContext"/> is updated for the latest TargetFrameworks from the project properties
/// and returns this value.
/// </summary>
private Task <AggregateCrossTargetProjectContext> UpdateProjectContextAsync()
{
// Ensure that only single thread is attempting to create a project context.
return(ExecuteWithinLockAsync(async() =>
{
AggregateCrossTargetProjectContext previousContext = _currentAggregateProjectContext;
// Check if we have already computed the project context.
if (previousContext != null)
{
// For non-cross targeting projects, we can use the current project context if the TargetFramework hasn't changed.
// For cross-targeting projects, we need to verify that the current project context matches latest frameworks targeted by the project.
// If not, we create a new one and dispose the current one.
ConfigurationGeneral projectProperties = await _commonServices.ActiveConfiguredProjectProperties.GetConfigurationGeneralPropertiesAsync();
if (!previousContext.IsCrossTargeting)
{
ITargetFramework newTargetFramework = _targetFrameworkProvider.GetTargetFramework((string)await projectProperties.TargetFramework.GetValueAsync());
if (previousContext.ActiveTargetFramework.Equals(newTargetFramework))
{
return previousContext;
}
}
else
{
// Check if the current project context is up-to-date for the current active and known project configurations.
ProjectConfiguration activeProjectConfiguration = _commonServices.ActiveConfiguredProject.ProjectConfiguration;
IImmutableSet <ProjectConfiguration> knownProjectConfigurations = await _commonServices.Project.Services.ProjectConfigurationsService.GetKnownProjectConfigurationsAsync();
if (knownProjectConfigurations.All(c => c.IsCrossTargeting()) &&
previousContext.HasMatchingTargetFrameworks(activeProjectConfiguration, knownProjectConfigurations))
{
return previousContext;
}
}
}
// Force refresh the CPS active project configuration (needs UI thread).
await _commonServices.ThreadingService.SwitchToUIThread();
await _activeProjectConfigurationRefreshService.RefreshActiveProjectConfigurationAsync();
// Create new project context.
_currentAggregateProjectContext = await _contextProvider.Value.CreateProjectContextAsync();
OnAggregateContextChanged(previousContext, _currentAggregateProjectContext);
return _currentAggregateProjectContext;
}));
}
public void AddSubscriptions(AggregateCrossTargetProjectContext projectContext)
{
Requires.NotNull(projectContext, nameof(projectContext));
_currentProjectContext = projectContext;
IReadOnlyCollection <string> watchedEvaluationRules = GetRuleNames(RuleSource.Evaluation);
IReadOnlyCollection <string> watchedJointRules = GetRuleNames(RuleSource.Joint);
_treeTelemetryService.InitializeTargetFrameworkRules(projectContext.TargetFrameworks, watchedJointRules);
foreach (ConfiguredProject configuredProject in projectContext.InnerConfiguredProjects)
{
SubscribeToConfiguredProject(
configuredProject, configuredProject.Services.ProjectSubscription, watchedEvaluationRules, watchedJointRules);
}
}
protected override void Handle(
AggregateCrossTargetProjectContext currentAggregateContext,
TargetFramework targetFrameworkToUpdate,
EventData e)
{
IProjectSharedFoldersSnapshot sharedProjectsUpdate = e.Item2;
IProjectCatalogSnapshot catalogs = e.Item3;
var changesBuilder = new DependenciesChangesBuilder();
ProcessSharedProjectsUpdates(sharedProjectsUpdate, targetFrameworkToUpdate, changesBuilder);
IDependenciesChanges?changes = changesBuilder.TryBuildChanges();
if (changes != null)
{
RaiseDependenciesChanged(targetFrameworkToUpdate, changes, currentAggregateContext, catalogs);
}
}
protected override void Handle(
AggregateCrossTargetProjectContext currentAggregateContext,
TargetFramework targetFrameworkToUpdate,
EventData e)
{
IProjectSubscriptionUpdate projectUpdate = e.Item1;
IProjectCatalogSnapshot catalogSnapshot = e.Item2;
// 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 DependenciesChangesBuilder();
// Give each handler a chance to register dependency changes.
foreach (Lazy <IDependenciesRuleHandler, IOrderPrecedenceMetadataView> handler in _handlers)
{
handler.Value.Handle(projectUpdate.ProjectChanges, targetFrameworkToUpdate, changesBuilder);
}
IDependenciesChanges?changes = changesBuilder.TryBuildChanges();
// Notify subscribers of a change in dependency data.
// NOTE even if changes is null, it's possible the catalog has changed. If we don't take the newer
// catalog we end up retaining a reference to an old catalog, which in turn retains an old project
// instance which can be very large.
RaiseDependenciesChanged(targetFrameworkToUpdate, changes, currentAggregateContext, catalogSnapshot);
// Record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(targetFrameworkToUpdate, projectUpdate.ProjectChanges.Keys);
}
protected override void OnAggregateContextChanged(
AggregateCrossTargetProjectContext oldContext,
AggregateCrossTargetProjectContext newContext)
{
if (oldContext == null)
{
// all new rules will be sent to new context , we don't need to clean up anything
return;
}
var targetsToClean = new HashSet <ITargetFramework>();
IEnumerable <ITargetFramework> oldTargets = oldContext.InnerProjectContexts
.Select(x => x.TargetFramework)
.Where(x => x != null);
if (newContext == null)
{
targetsToClean.AddRange(oldTargets);
}
else
{
IEnumerable <ITargetFramework> newTargets = newContext.InnerProjectContexts
.Select(x => x.TargetFramework)
.Where(x => x != null);
targetsToClean.AddRange(oldTargets.Except(newTargets));
}
if (targetsToClean.Count == 0)
{
return;
}
lock (_snapshotLock)
{
_currentSnapshot = _currentSnapshot.RemoveTargets(targetsToClean);
}
ScheduleDependenciesUpdate();
}
protected override void Handle(
string projectFullPath,
AggregateCrossTargetProjectContext currentAggregateContext,
TargetFramework targetFrameworkToUpdate,
EventData e)
{
IProjectSubscriptionUpdate projectUpdate = e.Item1;
IProjectCatalogSnapshot catalogSnapshot = e.Item2;
// Broken design-time builds can produce updates containing no rule data.
// Later code assumes that the requested rules are available.
// If we see no rule data, return now.
if (projectUpdate.ProjectChanges.Count == 0)
{
return;
}
// Create an object to track dependency changes.
var changesBuilder = new DependenciesChangesBuilder();
// Give each handler a chance to register dependency changes.
foreach (Lazy <IDependenciesRuleHandler, IOrderPrecedenceMetadataView> handler in _handlers)
{
IProjectChangeDescription evaluation = projectUpdate.ProjectChanges[handler.Value.EvaluatedRuleName];
IProjectChangeDescription?build = projectUpdate.ProjectChanges.GetValueOrDefault(handler.Value.ResolvedRuleName);
handler.Value.Handle(projectFullPath, evaluation, build, targetFrameworkToUpdate, changesBuilder);
}
IDependenciesChanges?changes = changesBuilder.TryBuildChanges();
// Notify subscribers of a change in dependency data.
// NOTE even if changes is null, it's possible the catalog has changed. If we don't take the newer
// catalog we end up retaining a reference to an old catalog, which in turn retains an old project
// instance which can be very large.
RaiseDependenciesChanged(targetFrameworkToUpdate, changes, currentAggregateContext, catalogSnapshot);
// Record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(targetFrameworkToUpdate, projectUpdate.ProjectChanges.Keys);
}
public void AddSubscriptions(AggregateCrossTargetProjectContext projectContext)
{
Requires.NotNull(projectContext, nameof(projectContext));
_currentProjectContext = projectContext;
IReadOnlyCollection <string> watchedEvaluationRules = GetWatchedRules(RuleHandlerType.Evaluation);
IReadOnlyCollection <string> watchedDesignTimeBuildRules = GetWatchedRules(RuleHandlerType.DesignTimeBuild);
// initialize telemetry with all rules for each target framework
foreach (ITargetFramework targetFramework in projectContext.TargetFrameworks)
{
_treeTelemetryService.InitializeTargetFrameworkRules(targetFramework, watchedEvaluationRules);
_treeTelemetryService.InitializeTargetFrameworkRules(targetFramework, watchedDesignTimeBuildRules);
}
foreach (ConfiguredProject configuredProject in projectContext.InnerConfiguredProjects)
{
SubscribeToConfiguredProject(
configuredProject, configuredProject.Services.ProjectSubscription, watchedEvaluationRules, watchedDesignTimeBuildRules);
}
}
private void OnAggregateContextChanged(
AggregateCrossTargetProjectContext oldContext,
AggregateCrossTargetProjectContext newContext)
{
if (oldContext == null)
{
// all new rules will be sent to new context , we don't need to clean up anything
return;
}
var targetsToClean = new HashSet <ITargetFramework>();
ImmutableArray <ITargetFramework> oldTargets = oldContext.TargetFrameworks;
if (newContext == null)
{
targetsToClean.AddRange(oldTargets);
}
else
{
ImmutableArray <ITargetFramework> newTargets = newContext.TargetFrameworks;
targetsToClean.AddRange(oldTargets.Except(newTargets));
}
if (targetsToClean.Count == 0)
{
return;
}
lock (_snapshotLock)
{
_currentSnapshot = _currentSnapshot.RemoveTargets(targetsToClean);
}
ScheduleDependenciesUpdate();
}
private Task AddSubscriptionsAsync(AggregateCrossTargetProjectContext newProjectContext)
{
Requires.NotNull(newProjectContext, nameof(newProjectContext));
return(_tasksService.LoadedProjectAsync(() =>
{
lock (_linksLock)
{
foreach (ConfiguredProject configuredProject in newProjectContext.InnerConfiguredProjects)
{
SubscribeToConfiguredProjectEvaluation(
configuredProject.Services.ProjectSubscription,
OnConfiguredProjectEvaluatedAsync);
}
foreach (IDependencyCrossTargetSubscriber subscriber in Subscribers)
{
subscriber.AddSubscriptions(newProjectContext);
}
}
return Task.CompletedTask;
}));
}
private async Task HandleAsync(
IProjectSubscriptionUpdate projectUpdate,
IProjectCatalogSnapshot catalogSnapshot,
RuleHandlerType handlerType)
{
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;
}
// 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)
{
ImmutableHashSet <string> handlerRules = handler.Value.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 (projectChanges.Any(x => x.Value.Difference.AnyChanges))
{
handler.Value.Handle(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.ActiveTargetFramework,
catalogSnapshot,
changes));
}
// record all the rules that have occurred
_treeTelemetryService.ObserveTargetFrameworkRules(targetFrameworkToUpdate, projectUpdate.ProjectChanges.Keys);
}
/// <summary>
/// Determines whether the current project context object is out of date based on the project's target frameworks.
/// If so, a new one is created and subscriptions are updated accordingly.
/// </summary>
private async Task UpdateProjectContextAndSubscriptionsAsync()
{
// Ensure that only single thread is attempting to create a project context.
AggregateCrossTargetProjectContext newProjectContext = await ExecuteWithinLockAsync(TryUpdateCurrentAggregateProjectContextAsync);
if (newProjectContext != null)
{
// Dispose existing subscriptions.
DisposeAndClearSubscriptions();
// Add subscriptions for the configured projects in the new project context.
await AddSubscriptionsAsync(newProjectContext);
}
return;
async Task <AggregateCrossTargetProjectContext> TryUpdateCurrentAggregateProjectContextAsync()
{
AggregateCrossTargetProjectContext previousContext = _currentAggregateProjectContext;
// Check if we have already computed the project context.
if (previousContext != null)
{
// For non-cross targeting projects, we can use the current project context if the TargetFramework hasn't changed.
// For cross-targeting projects, we need to verify that the current project context matches latest frameworks targeted by the project.
// If not, we create a new one and dispose the current one.
ConfigurationGeneral projectProperties = await _commonServices.ActiveConfiguredProjectProperties.GetConfigurationGeneralPropertiesAsync();
if (!previousContext.IsCrossTargeting)
{
string newTargetFrameworkName = (string)await projectProperties.TargetFramework.GetValueAsync();
ITargetFramework newTargetFramework = _targetFrameworkProvider.GetTargetFramework(newTargetFrameworkName);
if (previousContext.ActiveTargetFramework.Equals(newTargetFramework))
{
// No change
return(null);
}
}
else
{
// Check if the current project context is up-to-date for the current active and known project configurations.
ProjectConfiguration activeProjectConfiguration = _commonServices.ActiveConfiguredProject.ProjectConfiguration;
IImmutableSet <ProjectConfiguration> knownProjectConfigurations = await _commonServices.Project.Services.ProjectConfigurationsService.GetKnownProjectConfigurationsAsync();
if (knownProjectConfigurations.All(c => c.IsCrossTargeting()) &&
HasMatchingTargetFrameworks(previousContext, activeProjectConfiguration, knownProjectConfigurations))
{
// No change
return(null);
}
}
}
// Force refresh the CPS active project configuration (needs UI thread).
await _commonServices.ThreadingService.SwitchToUIThread();
await _activeProjectConfigurationRefreshService.RefreshActiveProjectConfigurationAsync();
// Create new project context.
AggregateCrossTargetProjectContext newContext = await _contextProvider.Value.CreateProjectContextAsync();
_currentAggregateProjectContext = newContext;
OnAggregateContextChanged(previousContext, newContext);
return(newContext);
}
bool HasMatchingTargetFrameworks(
AggregateCrossTargetProjectContext previousContext,
ProjectConfiguration activeProjectConfiguration,
IReadOnlyCollection <ProjectConfiguration> knownProjectConfigurations)
{
Assumes.True(activeProjectConfiguration.IsCrossTargeting());
ITargetFramework activeTargetFramework = _targetFrameworkProvider.GetTargetFramework(activeProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty]);
if (!previousContext.ActiveTargetFramework.Equals(activeTargetFramework))
{
// Active target framework is different.
return(false);
}
var targetFrameworkMonikers = knownProjectConfigurations
.Select(c => c.Dimensions[ConfigurationGeneral.TargetFrameworkProperty])
.Distinct()
.ToList();
if (targetFrameworkMonikers.Count != previousContext.TargetFrameworks.Length)
{
// Different number of target frameworks.
return(false);
}
foreach (string targetFrameworkMoniker in targetFrameworkMonikers)
{
ITargetFramework targetFramework = _targetFrameworkProvider.GetTargetFramework(targetFrameworkMoniker);
if (!previousContext.TargetFrameworks.Contains(targetFramework))
{
// Differing TargetFramework
return(false);
}
}
return(true);
}
void OnAggregateContextChanged(
AggregateCrossTargetProjectContext oldContext,
AggregateCrossTargetProjectContext newContext)
{
if (oldContext == null)
{
// all new rules will be sent to new context, we don't need to clean up anything
return;
}
var targetsToClean = new HashSet <ITargetFramework>();
ImmutableArray <ITargetFramework> oldTargets = oldContext.TargetFrameworks;
if (newContext == null)
{
targetsToClean.AddRange(oldTargets);
}
else
{
ImmutableArray <ITargetFramework> newTargets = newContext.TargetFrameworks;
targetsToClean.AddRange(oldTargets.Except(newTargets));
}
if (targetsToClean.Count != 0)
{
TryUpdateSnapshot(snapshot => snapshot.RemoveTargets(targetsToClean));
}
}
}
public override void AddSubscriptions(AggregateCrossTargetProjectContext projectContext)
{
_treeTelemetryService.InitializeTargetFrameworkRules(projectContext.TargetFrameworks, _watchedJointRules.Value);
base.AddSubscriptions(projectContext);
}
public async Task <AggregateCrossTargetProjectContext?> TryUpdateCurrentAggregateProjectContextAsync()
{
AggregateCrossTargetProjectContext?previousContext = Current;
// Check if we have already computed the project context.
if (previousContext != null)
{
// For non-cross targeting projects, we can use the current project context if the TargetFramework hasn't changed.
// For cross-targeting projects, we need to verify that the current project context matches latest frameworks targeted by the project.
// If not, we create a new one and dispose the current one.
ConfigurationGeneral projectProperties = await _commonServices.ActiveConfiguredProjectProperties.GetConfigurationGeneralPropertiesAsync();
if (!previousContext.IsCrossTargeting)
{
string?newTargetFrameworkName = (string?)await projectProperties.TargetFrameworkMoniker.GetValueAsync();
if (string.IsNullOrEmpty(newTargetFrameworkName) && TargetFramework.Empty.Equals(previousContext.ActiveTargetFramework))
{
// No change
return(null);
}
TargetFramework?newTargetFramework = _targetFrameworkProvider.GetTargetFramework(newTargetFrameworkName);
if (previousContext.ActiveTargetFramework.Equals(newTargetFramework))
{
// No change
return(null);
}
}
else
{
// Check if the current project context is up-to-date for the current active and known project configurations.
Assumes.Present(_commonServices.Project.Services.ProjectConfigurationsService);
ProjectConfiguration activeProjectConfiguration = _commonServices.ActiveConfiguredProject.ProjectConfiguration;
IImmutableSet <ProjectConfiguration> knownProjectConfigurations = await _commonServices.Project.Services.ProjectConfigurationsService.GetKnownProjectConfigurationsAsync();
if (knownProjectConfigurations.All(c => c.IsCrossTargeting()) &&
HasMatchingTargetFrameworks(activeProjectConfiguration, knownProjectConfigurations))
{
// No change
return(null);
}
}
}
// Force refresh the CPS active project configuration (needs UI thread).
await _commonServices.ThreadingService.SwitchToUIThread();
await _activeProjectConfigurationRefreshService.RefreshActiveProjectConfigurationAsync();
// Create new project context.
AggregateCrossTargetProjectContext newContext = await _contextProvider.Value.CreateProjectContextAsync();
Current = newContext;
return(newContext);
bool HasMatchingTargetFrameworks(
ProjectConfiguration activeProjectConfiguration,
IReadOnlyCollection <ProjectConfiguration> knownProjectConfigurations)
{
Assumes.NotNull(previousContext);
Assumes.True(activeProjectConfiguration.IsCrossTargeting());
TargetFramework?activeTargetFramework = _targetFrameworkProvider.GetTargetFramework(activeProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty]);
if (!previousContext.ActiveTargetFramework.Equals(activeTargetFramework))
{
// Active target framework is different.
return(false);
}
var targetFrameworkMonikers = knownProjectConfigurations
.Select(c => c.Dimensions[ConfigurationGeneral.TargetFrameworkProperty])
.Distinct()
.ToList();
if (targetFrameworkMonikers.Count != previousContext.TargetFrameworks.Length)
{
// Different number of target frameworks.
return(false);
}
foreach (string targetFrameworkMoniker in targetFrameworkMonikers)
{
TargetFramework?targetFramework = _targetFrameworkProvider.GetTargetFramework(targetFrameworkMoniker);
if (targetFramework == null || !previousContext.TargetFrameworks.Contains(targetFramework))
{
// Differing TargetFramework
return(false);
}
}
return(true);
}
}
