private async Task EnqueueProjectConfigurationChangeWorkItemAsync(ProjectChanges projectChanges)
{
var oldProject = projectChanges.OldProject;
var newProject = projectChanges.NewProject;
// TODO: why solution changes return Project not ProjectId but ProjectChanges return DocumentId not Document?
var projectConfigurationChange = InvocationReasons.Empty;
if (!object.Equals(oldProject.ParseOptions, newProject.ParseOptions))
{
projectConfigurationChange = projectConfigurationChange.With(InvocationReasons.ProjectParseOptionChanged);
}
if (projectChanges.GetAddedMetadataReferences().Any() ||
projectChanges.GetAddedProjectReferences().Any() ||
projectChanges.GetAddedAnalyzerReferences().Any() ||
projectChanges.GetRemovedMetadataReferences().Any() ||
projectChanges.GetRemovedProjectReferences().Any() ||
projectChanges.GetRemovedAnalyzerReferences().Any() ||
!object.Equals(oldProject.CompilationOptions, newProject.CompilationOptions) ||
!object.Equals(oldProject.AssemblyName, newProject.AssemblyName) ||
!object.Equals(oldProject.Name, newProject.Name) ||
!object.Equals(oldProject.AnalyzerOptions, newProject.AnalyzerOptions))
{
projectConfigurationChange = projectConfigurationChange.With(InvocationReasons.ProjectConfigurationChanged);
}
if (!projectConfigurationChange.IsEmpty)
{
await EnqueueWorkItemAsync(projectChanges.NewProject, projectConfigurationChange).ConfigureAwait(false);
}
}
public override IProjectSubscriptionUpdate ToActualModel()
{
IImmutableDictionary <string, IProjectRuleSnapshot> currentState;
IImmutableDictionary <string, IProjectChangeDescription> projectChanges;
ProjectConfiguration projectConfiguration;
if (CurrentState != null)
{
currentState = CurrentState.Select(x => new KeyValuePair <string, IProjectRuleSnapshot>(x.Key, x.Value)).ToImmutableDictionary();
}
else
{
currentState = ImmutableDictionary <string, IProjectRuleSnapshot> .Empty;
}
if (ProjectChanges != null)
{
projectChanges = ProjectChanges.Select(x => new KeyValuePair <string, IProjectChangeDescription>(x.Key, x.Value.ToActualModel())).ToImmutableDictionary();
}
else
{
projectChanges = ImmutableDictionary <string, IProjectChangeDescription> .Empty;
}
if (ProjectConfiguration != null)
{
projectConfiguration = ProjectConfiguration.ToActualModel();
}
else
{
projectConfiguration = ProjectConfigurationFactory.Create("TEST");
}
return(new ActualModel(currentState, projectChanges, projectConfiguration));
}
public override IProjectSubscriptionUpdate ToActualModel()
{
var model = new ActualModel();
if (CurrentState != null)
{
model.CurrentState = CurrentState.Select(x => new KeyValuePair <string, IProjectRuleSnapshot>(x.Key, x.Value))
.ToImmutableDictionary();
}
else
{
model.CurrentState = ImmutableDictionary <string, IProjectRuleSnapshot> .Empty;
}
if (ProjectChanges != null)
{
model.ProjectChanges = ProjectChanges.Select(x => new KeyValuePair <string, IProjectChangeDescription>(x.Key, x.Value.ToActualModel()))
.ToImmutableDictionary();
}
else
{
model.ProjectChanges = ImmutableDictionary <string, IProjectChangeDescription> .Empty;
}
if (ProjectConfiguration != null)
{
model.ProjectConfiguration = ProjectConfiguration.ToActualModel();
}
return(model);
}
protected override void ApplyProjectChanges(ProjectChanges projectChanges)
{
try {
internalChanges = true;
base.ApplyProjectChanges(projectChanges);
} finally {
internalChanges = false;
}
}
private bool HasProjectFileChanges(ProjectChanges changes)
{
return(changes.GetAddedDocuments().Any() ||
changes.GetRemovedDocuments().Any() ||
changes.GetAddedMetadataReferences().Any() ||
changes.GetRemovedMetadataReferences().Any() ||
changes.GetAddedProjectReferences().Any() ||
changes.GetRemovedProjectReferences().Any() ||
changes.GetAddedAnalyzerReferences().Any() ||
changes.GetRemovedAnalyzerReferences().Any());
}
protected override void ApplyProjectChanges(ProjectChanges projectChanges)
{
if (projectChanges.OldProject.FilePath != projectChanges.NewProject.FilePath)
{
var hostProject = this.GetTestProject(projectChanges.NewProject.Id);
hostProject.OnProjectFilePathChanged(projectChanges.NewProject.FilePath);
base.OnProjectNameChanged(projectChanges.NewProject.Id, projectChanges.NewProject.Name, projectChanges.NewProject.FilePath);
}
base.ApplyProjectChanges(projectChanges);
}
protected override void ApplyProjectChanges(ProjectChanges projectChanges)
{
// since Roslyn currently doesn't handle DefaultNamespace changes via ApplyProjectChanges
// and OnDefaultNamespaceChanged is internal, we use reflection for now
if (projectChanges.NewProject.DefaultNamespace != projectChanges.OldProject.DefaultNamespace)
{
var onDefaultNamespaceChanged = this.GetType().GetMethod("OnDefaultNamespaceChanged", BindingFlags.Instance | BindingFlags.NonPublic);
if (onDefaultNamespaceChanged != null)
{
onDefaultNamespaceChanged.Invoke(this, new object[] { projectChanges.ProjectId, projectChanges.NewProject.DefaultNamespace });
}
}
base.ApplyProjectChanges(projectChanges);
}
/// <summary>
/// Saves the updated documents to disk.
/// </summary>
/// <param name="projectChanges">The project changes.</param>
/// <param name="newSolution">The new solution.</param>
private static void SaveUpdatedDocumentsToDisk(ProjectChanges projectChanges, Solution newSolution)
{
var s_utf8WithoutBom = new UTF8Encoding(false);
var changedDocumentIds = projectChanges.GetChangedDocuments(true).ToList();
changedDocumentIds.ForEach(documentId =>
{
var document = newSolution.GetDocument(documentId);
var text = document.GetTextAsync();
using (var writer = new StreamWriter(document.FilePath, append: false, encoding: text.Result.Encoding ?? s_utf8WithoutBom))
{
text.Result.Write(writer);
}
});
}
protected override void ApplyProjectChanges(ProjectChanges projectChanges)
{
System.Diagnostics.Debug.Assert(this.applyChangesProjectFile == null);
var project = projectChanges.OldProject ?? projectChanges.NewProject;
try
{
// if we need to modify the project file, load it first.
if (projectChanges.GetAddedDocuments().Any() ||
projectChanges.GetRemovedDocuments().Any())
{
var projectPath = project.FilePath;
IProjectFileLoader loader;
if (this.TryGetLoaderFromProjectPath(projectPath, ReportMode.Ignore, out loader))
{
try
{
this.applyChangesProjectFile = loader.LoadProjectFileAsync(projectPath, this.properties, CancellationToken.None).Result;
}
catch (System.IO.IOException exception)
{
this.OnWorkspaceFailed(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId));
}
}
}
// do normal apply operations
base.ApplyProjectChanges(projectChanges);
// save project file
if (this.applyChangesProjectFile != null)
{
try
{
this.applyChangesProjectFile.Save();
}
catch (System.IO.IOException exception)
{
this.OnWorkspaceFailed(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId));
}
}
}
finally
{
this.applyChangesProjectFile = null;
}
}
private void Update(Project project, ProjectChanges changes)
{
foreach (var task in changes.AddedTasks.Select(project.GetTask).OrderBy(o => o.Ordinal))
{
var row = new TaskGridRowViewModel(Workspace, task.Id);
Rows.Add(row);
_rowMap.Add(task.Id, row);
}
foreach (var taskId in changes.RemovedTasks)
{
Rows.Remove(_rowMap[taskId]);
_rowMap.Remove(taskId);
}
foreach (var taskChanges in changes.ChangedTasks)
{
_rowMap[taskChanges.Id].Update(taskChanges);
}
}
private async Task EnqueueWorkItemAsync(ProjectChanges projectChanges)
{
await EnqueueProjectConfigurationChangeWorkItemAsync(projectChanges).ConfigureAwait(false);
foreach (var addedDocumentId in projectChanges.GetAddedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.NewProject.GetRequiredDocument(addedDocumentId), InvocationReasons.DocumentAdded).ConfigureAwait(false);
}
foreach (var changedDocumentId in projectChanges.GetChangedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.OldProject.GetRequiredDocument(changedDocumentId), projectChanges.NewProject.GetRequiredDocument(changedDocumentId))
.ConfigureAwait(continueOnCapturedContext: false);
}
foreach (var removedDocumentId in projectChanges.GetRemovedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.OldProject.GetRequiredDocument(removedDocumentId), InvocationReasons.DocumentRemoved).ConfigureAwait(false);
}
}
private void Update(Project project, ProjectChanges changes)
{
foreach (var resource in changes.AddedResources.Select(project.GetResource))
{
var row = new ResourceGridRowViewModel(Workspace, resource.Id);
Rows.Add(row);
_rowMap.Add(resource.Id, row);
}
foreach (var resourceId in changes.RemovedResources)
{
Rows.Remove(_rowMap[resourceId]);
_rowMap.Remove(resourceId);
}
foreach (var resourceChanges in changes.ChangedResources)
{
_rowMap[resourceChanges.Id].Update(resourceChanges);
}
}
private bool ProjectReferencesChanged(ProjectChanges projectChanges)
{
var oldProjectReferences = projectChanges.OldProject.ProjectReferences.ToDictionary(r => r.ProjectId);
var newProjectReferences = projectChanges.NewProject.ProjectReferences.ToDictionary(r => r.ProjectId);
// These are the set of project reference that remained in the project. We don't care
// about project references that were added or removed. Those will already be reported.
var preservedProjectIds = oldProjectReferences.Keys.Intersect(newProjectReferences.Keys);
foreach (var projectId in preservedProjectIds)
{
var oldProjectReference = oldProjectReferences[projectId];
var newProjectReference = newProjectReferences[projectId];
if (!oldProjectReference.Equals(newProjectReference))
{
return(true);
}
}
return(false);
}
private void Update(Project project, ProjectChanges changes)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (changes == null)
{
throw new ArgumentNullException(nameof(changes));
}
Current = project;
foreach (var task in changes.AddedTasks.Select(project.GetTask).OrderBy(o => o.Ordinal))
{
var taskViewModel = new GanttTaskViewModel(Workspace, task.Id);
Tasks.Add(taskViewModel);
}
foreach (var taskId in changes.RemovedTasks)
{
var taskViewModel = Tasks.SingleOrDefault(vm => vm.TaskId == taskId);
if (taskViewModel != null)
{
Tasks.Remove(taskViewModel);
}
}
foreach (var taskChanges in changes.ChangedTasks)
{
var taskViewModel = Tasks.SingleOrDefault(vm => vm.TaskId == taskChanges.Id);
if (taskViewModel != null)
{
taskViewModel.Update(taskChanges);
}
}
}
private void Update(Project project, ProjectChanges changes)
{
foreach (var assignment in changes.AddedAssignments
.Select(project.GetAssignment)
.OrderBy(a => a.Task.Ordinal)
.ThenBy(o => o.Resource.Name))
{
var row = new AssignmentGridRowViewModel(Workspace, assignment.Id);
Rows.Add(row);
_rowMap.Add(assignment.Id, row);
}
foreach (var assignmentId in changes.RemovedAssignments)
{
Rows.Remove(_rowMap[assignmentId]);
_rowMap.Remove(assignmentId);
}
foreach (var assignmentChanges in changes.ChangedAssignments)
{
_rowMap[assignmentChanges.Id].Update(assignmentChanges);
}
}
private bool ProjectReferencesChanged(ProjectChanges projectChanges)
{
var oldProjectReferences = projectChanges.OldProject.ProjectReferences.ToDictionary(r => r.ProjectId);
var newProjectReferences = projectChanges.NewProject.ProjectReferences.ToDictionary(r => r.ProjectId);
// These are the set of project reference that remained in the project. We don't care
// about project references that were added or removed. Those will already be reported.
var preservedProjectIds = oldProjectReferences.Keys.Intersect(newProjectReferences.Keys);
foreach (var projectId in preservedProjectIds)
{
var oldProjectReference = oldProjectReferences[projectId];
var newProjectReference = newProjectReferences[projectId];
if (!oldProjectReference.Equals(newProjectReference))
{
return true;
}
}
return false;
}
private async Task EnqueueProjectConfigurationChangeWorkItemAsync(ProjectChanges projectChanges)
{
var oldProject = projectChanges.OldProject;
var newProject = projectChanges.NewProject;
// TODO: why solution changes return Project not ProjectId but ProjectChanges return DocumentId not Document?
var projectConfigurationChange = InvocationReasons.Empty;
if (!object.Equals(oldProject.ParseOptions, newProject.ParseOptions))
{
projectConfigurationChange = projectConfigurationChange.With(InvocationReasons.ProjectParseOptionChanged);
}
if (projectChanges.GetAddedMetadataReferences().Any() || projectChanges.GetAddedProjectReferences().Any() || projectChanges.GetAddedAnalyzerReferences().Any() ||
projectChanges.GetRemovedMetadataReferences().Any() || projectChanges.GetRemovedProjectReferences().Any() || projectChanges.GetRemovedAnalyzerReferences().Any() ||
!object.Equals(oldProject.CompilationOptions, newProject.CompilationOptions) ||
!object.Equals(oldProject.AssemblyName, newProject.AssemblyName) ||
!object.Equals(oldProject.AnalyzerOptions, newProject.AnalyzerOptions))
{
projectConfigurationChange = projectConfigurationChange.With(InvocationReasons.ProjectConfigurationChanged);
}
if (!projectConfigurationChange.IsEmpty)
{
await EnqueueWorkItemAsync(projectChanges.NewProject, projectConfigurationChange).ConfigureAwait(false);
}
}
private async Task EnqueueWorkItemAsync(ProjectChanges projectChanges)
{
await EnqueueProjectConfigurationChangeWorkItemAsync(projectChanges).ConfigureAwait(false);
foreach (var addedDocumentId in projectChanges.GetAddedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.NewProject.GetDocument(addedDocumentId), InvocationReasons.DocumentAdded).ConfigureAwait(false);
}
foreach (var changedDocumentId in projectChanges.GetChangedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.OldProject.GetDocument(changedDocumentId), projectChanges.NewProject.GetDocument(changedDocumentId))
.ConfigureAwait(continueOnCapturedContext: false);
}
foreach (var removedDocumentId in projectChanges.GetRemovedDocuments())
{
await EnqueueWorkItemAsync(projectChanges.OldProject.GetDocument(removedDocumentId), InvocationReasons.DocumentRemoved).ConfigureAwait(false);
}
}
public ProjectChangedEventArgs(Project oldProject, Project newProject, ProjectChanges changes)
{
OldProject = oldProject;
NewProject = newProject;
Changes = changes;
}
