feat: add caching

src/Dependify.Core/MsBuildService.cs

@@ -6,11 +6,11 @@
 using Microsoft.Build.Construction;
 using Microsoft.Extensions.Logging;
 
 public class MsBuildService : IDisposable
 {
     private readonly ILogger<MsBuildService> logger;
     private readonly ILoggerFactory loggerFactory;
     private readonly Subject<NodeEvent> subject;
 
     public IObservable<NodeEvent> OnLoadingEvents { get; }
 
@@ -23,6 +23,24 @@
     }
 
     public DependencyGraph AnalyzeReferences(SolutionReferenceNode solution, MsBuildConfig config)
+    {
+        return this.AnalyzeReferencesCore(solution, config, null);
+    }
+
+    public DependencyGraph AnalyzeReferencesWithCache(
+        SolutionReferenceNode solution,
+        MsBuildConfig config,
+        DependencyGraph cache
+    )
+    {
+        return this.AnalyzeReferencesCore(solution, config, cache);
+    }
+
+    private DependencyGraph AnalyzeReferencesCore(
+        SolutionReferenceNode solution,
+        MsBuildConfig config,
+        DependencyGraph? cache
+    )
     {
         this.logger.LogInformation("Analyzing solution {Solution}", solution.Path);
         this.subject.OnNext(new NodeEvent(NodeEventType.SolutionLoading, solution.Id, solution.Path));
@@ -40,10 +58,18 @@
 
         foreach (var project in projects)
         {
-            var projectNode = new ProjectReferenceNode(project.Key);
-            builder.WithEdge(new Edge(builder.Root, projectNode));
+            var projectNode = new ProjectReferenceNode(project.Value.ProjectFile.Path);
 
-            this.AddDependenciesToGraph(builder, project.Value, projectNode, config);
+            if (cache is not null && cache.Nodes.Contains(projectNode))
+            {
+                this.CopyFromCache(builder, cache, projectNode);
+            }
+            else
+            {
+                builder.WithEdge(new Edge(builder.Root, projectNode));
+
+                this.AddDependenciesToGraph(builder, project.Value, projectNode, config);
+            }
         }
 
         if (config.FullScan)
@@ -53,7 +79,7 @@
             {
                 nodesToScan = builder.GetNotScannedNodes().OfType<ProjectReferenceNode>().ToList();
 
-                this.AnalyzeReferencesCore(builder, nodesToScan, config);
+                this.AnalyzeReferencesCore(builder, nodesToScan, config, cache);
             } while (nodesToScan.Count > 0);
         }
 
@@ -67,7 +93,7 @@
     {
         var builder = new DependencyGraph.Builder(node);
 
-        this.AnalyzeReferencesCore(builder, [node], config);
+        this.AnalyzeReferencesCore(builder, [node], config, null);
 
         return builder.Build();
     }
@@ -76,30 +102,39 @@
     {
         var builder = new DependencyGraph.Builder(new SolutionReferenceNode());
 
-        this.AnalyzeReferencesCore(builder, nodes, config);
+        this.AnalyzeReferencesCore(builder, nodes, config, null);
 
         return builder.Build();
     }
 
     private void AnalyzeReferencesCore(
         DependencyGraph.Builder builder,
         IEnumerable<ProjectReferenceNode> nodes,
-        MsBuildConfig config
+        MsBuildConfig config,
+        DependencyGraph? cache
     )
     {
         if (!nodes.Any())
         {
             return;
         }
 
         var analyzerManager = new AnalyzerManager(new AnalyzerManagerOptions { LoggerFactory = this.loggerFactory, });
 
         foreach (var path in nodes.Select(n => n.Path))
         {
             var projectNode = new ProjectReferenceNode(path);
-            var project = analyzerManager.GetProject(path);
 
-            this.AddDependenciesToGraph(builder, project, projectNode, config);
+            if (cache is not null && cache.Nodes.Contains(projectNode))
+            {
+                this.CopyFromCache(builder, cache, projectNode);
+            }
+            else
+            {
+                var project = analyzerManager.GetProject(path);
+
+                this.AddDependenciesToGraph(builder, project, projectNode, config);
+            }
         }
 
         if (config.FullScan)
@@ -109,11 +144,28 @@
             {
                 nodesToScan = builder.GetNotScannedNodes().OfType<ProjectReferenceNode>().ToList();
 
-                this.AnalyzeReferencesCore(builder, nodesToScan, config);
+                this.AnalyzeReferencesCore(builder, nodesToScan, config, cache);
             } while (nodesToScan.Count > 0);
         }
     }
 
+    private void CopyFromCache(DependencyGraph.Builder builder, DependencyGraph cache, ProjectReferenceNode projectNode)
+    {
+        var subgraph = cache.SubGraph(projectNode);
+
+        this.logger.LogInformation("Loaded project {Project} from cache", projectNode.Path);
+
+        foreach (var node in subgraph.Nodes)
+        {
+            builder.WithNode(node, scanned: true);
+        }
+
+        foreach (var edge in subgraph.Edges)
+        {
+            builder.WithEdge(edge);
+        }
+    }
+
     private void AddDependenciesToGraph(
         DependencyGraph.Builder builder,
         IProjectAnalyzer projectAnalyzer,
@@ -161,7 +213,7 @@
         }
     }
 
     public void Dispose()
     {
         this.subject.OnCompleted();
     }

src/Dependify.Core/SolutionRegistry.cs

@@ -4,7 +4,7 @@
 using System.Reactive.Subjects;
 using Dependify.Core.Graph;
 
 public class SolutionRegistry
 {
     private readonly Dictionary<SolutionReferenceNode, DependencyGraph> solutionGraphs = [];
     private static readonly object LockObject = new();
@@ -20,7 +20,7 @@
     public IList<Node> Nodes { get; private set; }
     public bool IsLoaded { get; private set; }
 
     public SolutionRegistry(FileProviderProjectLocator projectLocator, MsBuildService buildService)
     {
         this.projectLocator = projectLocator;
         this.buildService = buildService;
@@ -46,7 +46,7 @@
 
     public Task LoadSolutionsAsync(MsBuildConfig msBuildConfig, CancellationToken cancellationToken = default)
     {
-        this.IsLoaded = false;
+        this.ResetCache();
 
         lock (LockObject)
         {
@@ -61,7 +61,7 @@
                         this.Nodes.OfType<ProjectReferenceNode>().ToList(),
                         msBuildConfig
                     )
-                    : this.buildService.AnalyzeReferences(solution, msBuildConfig);
+                    : this.buildService.AnalyzeReferencesWithCache(solution, msBuildConfig, this.GetFullGraph());
 
                 this.solutionGraphs[solution] = dependencyGraph;
 
@@ -131,6 +131,12 @@
 
         return builder.Build();
     }
+
+    private void ResetCache()
+    {
+        this.IsLoaded = false;
+        this.solutionGraphs.Clear();
+    }
 }
 
 public record NodeUsage(