private async Task UpdateEntitiesFromSourceAsync(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var workspace = await _roslynModelProvider.GetWorkspaceAsync();
var projects = workspace.CurrentSolution.Projects;
var compilations = (await projects.SelectAsync(async i => await i.GetCompilationAsync(cancellationToken))).ToArray();
foreach (var roslynModelNode in Model.GetRoslynNodes())
{
cancellationToken.ThrowIfCancellationRequested();
var namedTypeSymbol = roslynModelNode.RoslynSymbol;
var newVersionOfSymbol = FindSymbolInCompilations(namedTypeSymbol, compilations, cancellationToken);
if (newVersionOfSymbol == null)
{
RemoveNode(roslynModelNode.Id);
}
else
{
var updatedNode = roslynModelNode.UpdateRoslynSymbol(newVersionOfSymbol);
UpdateNode(updatedNode);
}
progress?.Report(1);
}
}
private async Task <IReadOnlyList <IDiagramNode> > ShowEntitiesAsync(IReadOnlyList <IRoslynModelNode> modelEntities,
CancellationToken cancellationToken, IIncrementalProgress progress)
{
return(await Task.Run(
() => DiagramServices.ShowModelNodes(modelEntities, cancellationToken, progress).ToArray(),
cancellationToken));
}
public void ExtendModelWithRelatedEntities(IModelEntity modelEntity, EntityRelationType?entityRelationType = null,
CancellationToken cancellationToken = default(CancellationToken), IIncrementalProgress progress = null, bool recursive = false)
{
var roslynBasedModelEntity = modelEntity as RoslynBasedModelEntity;
if (roslynBasedModelEntity == null)
{
return;
}
var symbolRelations = roslynBasedModelEntity
.FindRelatedSymbols(_roslynModelProvider, entityRelationType)
.Select(GetOriginalDefinition)
.Where(i => !IsHidden(i.RelatedSymbol)).ToList();
foreach (var symbolRelation in symbolRelations)
{
cancellationToken.ThrowIfCancellationRequested();
var relatedEntity = GetOrAddEntity(symbolRelation.RelatedSymbol, progress);
AddRelationshipIfNotExists(symbolRelation);
// TODO: loop detection?
if (recursive)
{
ExtendModelWithRelatedEntities(relatedEntity, entityRelationType, cancellationToken, progress, recursive: true);
}
}
}
private async Task UpdateRelationshipsFromSourceAsync(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var allSymbolRelations = await Model.GetRoslynNodes().SelectManyAsync(
async i =>
{
var relatedSymbolPairs = await i.FindRelatedSymbolsAsync(_roslynModelProvider);
progress?.Report(1);
return(relatedSymbolPairs);
});
var distinctSymbolRelations = allSymbolRelations.Distinct().ToArray();
foreach (var relationship in Model.Relationships)
{
cancellationToken.ThrowIfCancellationRequested();
if (distinctSymbolRelations.All(i => !i.Matches(relationship)))
{
RemoveRelationship(relationship.Id);
}
progress?.Report(1);
}
}
private void UpdateRelationshipsFromSource(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var allSymbolRelations = _model.Entities.OfType <RoslynBasedModelEntity>()
.SelectMany(i =>
{
progress?.Report(1);
return(i.FindRelatedSymbols(_roslynModelProvider));
})
.Distinct().ToArray();
foreach (var relationship in _model.Relationships.OfType <ModelRelationship>().ToArray())
{
cancellationToken.ThrowIfCancellationRequested();
if (allSymbolRelations.All(i => !i.Matches(relationship)))
{
_model.RemoveRelationship(relationship);
}
progress?.Report(1);
}
}
private IRoslynBasedModelEntity GetOrAddEntity(INamedTypeSymbol namedTypeSymbol, IIncrementalProgress progress = null)
{
var modelEntity = _model.GetOrAddEntity(i => i.SymbolEquals(namedTypeSymbol), () => CreateModelEntity(namedTypeSymbol));
progress?.Report(1);
return(modelEntity);
}
private async Task <IReadOnlyList <IDiagramNode> > ExtendDiagramAsync(IRoslynModelNode modelNode,
CancellationToken cancellationToken, IIncrementalProgress progress)
{
return(await Task.Run(
() => DiagramServices.ShowModelNodeWithHierarchy(modelNode, cancellationToken, progress).ToArray(),
cancellationToken));
}
private void ExtendModelWithRelatedEntities(IRoslynModelNode modelEntity, CancellationToken cancellationToken, IIncrementalProgress progress)
{
ModelService.ExtendModelWithRelatedNodes(modelEntity, DirectedRelationshipTypes.BaseType, cancellationToken, progress, recursive: true);
ModelService.ExtendModelWithRelatedNodes(modelEntity, DirectedRelationshipTypes.Subtype, cancellationToken, progress, recursive: true);
}
public IEnumerable <IDiagramNode> ShowModelNodeWithHierarchy(IRoslynModelNode modelNode,
CancellationToken cancellationToken, IIncrementalProgress progress)
{
var model = ModelService.Model;
var baseTypes = model.GetRelatedNodes(modelNode.Id, DirectedRelationshipTypes.BaseType, recursive: true);
var subtypes = model.GetRelatedNodes(modelNode.Id, DirectedRelationshipTypes.Subtype, recursive: true);
var modelNodes = new[] { modelNode }.Union(baseTypes).Union(subtypes);
return(ShowModelNodes(modelNodes, cancellationToken, progress));
}
private async Task ExtendModelWithRelatedEntitiesAsync(IRoslynModelNode modelEntity,
CancellationToken cancellationToken, IIncrementalProgress progress)
{
await Task.WhenAll(
ModelService.ExtendModelWithRelatedNodesAsync(modelEntity, DirectedRelationshipTypes.BaseType, cancellationToken, progress, recursive: true),
ModelService.ExtendModelWithRelatedNodesAsync(modelEntity, DirectedRelationshipTypes.Subtype, cancellationToken, progress, recursive: true)
);
}
private async Task UpdateRelationshipsFromSourceAsync(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var allSymbolRelations = await LatestModel.Nodes.SelectManyAsync(
async i =>
{
var relatedSymbolPairs = await _relatedSymbolProvider.GetRelatedSymbolsAsync(GetSymbol(i));
progress?.Report(1);
return(relatedSymbolPairs);
});
var distinctSymbolRelations = allSymbolRelations.Distinct().ToArray();
foreach (var relationship in LatestModel.Relationships)
{
cancellationToken.ThrowIfCancellationRequested();
if (distinctSymbolRelations.All(i => !IsSymbolPairMatchingRelationship(i, relationship)))
{
_modelService.RemoveRelationship(relationship.Id);
}
progress?.Report(1);
}
}
private async Task UpdateEntitiesFromSourceAsync(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var workspace = await _roslynWorkspaceProvider.GetWorkspaceAsync();
var projects = workspace.CurrentSolution.Projects;
var compilations = (await projects.SelectAsync(async i => await i.GetCompilationAsync(cancellationToken))).ToArray();
foreach (var modelNode in LatestModel.Nodes)
{
cancellationToken.ThrowIfCancellationRequested();
var symbol = GetSymbol(modelNode);
var newVersionOfSymbol = FindSymbolInCompilations(symbol, compilations, cancellationToken);
if (newVersionOfSymbol == null)
{
_modelService.RemoveNode(modelNode.Id);
}
else
{
if (!ReferenceEquals(symbol, newVersionOfSymbol))
{
var updatedNode = modelNode.WithPayload(newVersionOfSymbol);
_modelService.UpdateNode(updatedNode);
}
}
progress?.Report(1);
}
}
public async Task UpdateFromSourceAsync(IEnumerable <ModelNodeId> visibleModelNodeIds,
CancellationToken cancellationToken = default(CancellationToken), IIncrementalProgress progress = null)
{
await UpdateEntitiesFromSourceAsync(cancellationToken, progress);
await UpdateRelationshipsFromSourceAsync(cancellationToken, progress);
foreach (var modelNodeId in visibleModelNodeIds)
{
if (Model.TryGetNode(modelNodeId, out var modelNode))
{
await ExtendModelWithRelatedNodesAsync(modelNode, null, cancellationToken, progress, recursive : false);
}
}
}
private void UpdateRelationshipsFromSource(CancellationToken cancellationToken, IIncrementalProgress progress)
{
cancellationToken.ThrowIfCancellationRequested();
var allSymbolRelations = CurrentRoslynModel.RoslynNodes
.SelectMany(i =>
{
progress?.Report(1);
return(i.FindRelatedSymbols(_roslynModelProvider));
})
.Distinct().ToArray();
foreach (var relationship in CurrentRoslynModel.Relationships)
{
cancellationToken.ThrowIfCancellationRequested();
if (allSymbolRelations.All(i => !i.Matches(relationship)))
{
RemoveRelationship(relationship.Id);
}
progress?.Report(1);
}
}
public void UpdateFromSource(CancellationToken cancellationToken = default(CancellationToken), IIncrementalProgress progress = null)
{
UpdateEntitiesFromSource(cancellationToken, progress);
UpdateRelationshipsFromSource(cancellationToken, progress);
}
private void ExtendModelWithRelatedNodesRecursive(IRoslynModelNode roslynModelNode, DirectedModelRelationshipType?directedModelRelationshipType,
CancellationToken cancellationToken, IIncrementalProgress progress, bool recursive, HashSet <ModelNodeId> alreadyDiscoveredNodes)
{
var relatedSymbolPairs = roslynModelNode
.FindRelatedSymbols(_roslynModelProvider, directedModelRelationshipType)
.Select(GetOriginalDefinition)
.Where(i => !IsHidden(i.RelatedSymbol)).ToList();
foreach (var relatedSymbolPair in relatedSymbolPairs)
{
cancellationToken.ThrowIfCancellationRequested();
var relatedSymbol = relatedSymbolPair.RelatedSymbol;
var relatedNode = GetOrAddNode(relatedSymbol, progress);
AddRelationshipIfNotExists(relatedSymbolPair);
if (!recursive)
{
continue;
}
// Avoid infinite loop by stopping recursion when a node is already added.
if (alreadyDiscoveredNodes.Contains(relatedNode.Id))
{
continue;
}
alreadyDiscoveredNodes.Add(relatedNode.Id);
ExtendModelWithRelatedNodesRecursive(relatedNode, directedModelRelationshipType,
cancellationToken, progress, true, alreadyDiscoveredNodes);
}
}
private async Task ExtendModelWithRelatedEntitiesAsync(IRoslynModelNode modelEntity,
CancellationToken cancellationToken, IIncrementalProgress progress)
{
await Task.Run(() => ExtendModelWithRelatedEntities(modelEntity, cancellationToken, progress), cancellationToken);
}
