Performance optimization

Author: ATrefzer

CSharpCodeAnalyst/Areas/GraphArea/GraphViewModel.cs

@@ -647,7 +647,7 @@ private void FindIncomingCalls(CodeElement method)
 
         // Use the node from the original graph
         var callee = _explorer.FindIncomingCalls(method.Id);
-        AddToGraph(callee.Methods, callee.Calls);
+        AddToGraph(callee.Elements, callee.Relationships);
     }
 
     internal void FindIncomingCallsRecursive(CodeElement method)
@@ -659,7 +659,7 @@ internal void FindIncomingCallsRecursive(CodeElement method)
 
         var callers =
             _explorer.FindIncomingCallsRecursive(method.Id);
-        AddToGraph(callers.Methods, callers.Calls);
+        AddToGraph(callers.Elements, callers.Relationships);
     }
 
 
@@ -695,7 +695,7 @@ private void FindOutgoingCalls(CodeElement? method)
         }
 
         var callers = _explorer.FindOutgoingCalls(method.Id);
-        AddToGraph(callers.Methods, callers.Calls);
+        AddToGraph(callers.Elements, callers.Relationships);
     }
 
     private static bool IsCallable(CodeElement? method)

CSharpCodeAnalyst/Exploration/CodeGraphExplorer.cs

@@ -11,8 +11,6 @@ public class CodeGraphExplorer : ICodeGraphExplorer
     public void LoadCodeGraph(CodeGraph graph)
     {
         _codeGraph = graph;
-
-        // Clear all cached data
     }
 
     public List<CodeElement> GetElements(List<string> ids)
@@ -148,30 +146,30 @@ public IEnumerable<Relationship> FindAllRelationships(HashSet<string> ids)
         return GetRelationships(d => ids.Contains(d.SourceId) && ids.Contains(d.TargetId));
     }
 
-    public Invocation FindIncomingCalls(string id)
+    public SearchResult FindIncomingCalls(string id)
     {
         ArgumentNullException.ThrowIfNull(id);
 
         if (_codeGraph is null || !_codeGraph.Nodes.TryGetValue(id, out var method))
         {
-            return new Invocation([], []);
+            return new SearchResult([], []);
         }
 
         var allCalls = GetRelationships(d => d.Type == RelationshipType.Calls);
         var calls = allCalls.Where(call => call.TargetId == method.Id).ToArray();
         var methods = calls.Select(d => _codeGraph.Nodes[d.SourceId]);
 
-        return new Invocation(methods, calls);
+        return new SearchResult(methods, calls);
     }
 
 
-    public Invocation FindIncomingCallsRecursive(string id)
+    public SearchResult FindIncomingCallsRecursive(string id)
     {
         ArgumentNullException.ThrowIfNull(id);
 
         if (_codeGraph is null || !_codeGraph.Nodes.TryGetValue(id, out var method))
         {
-            return new Invocation([], []);
+            return new SearchResult([], []);
         }
 
         var processingQueue = new Queue<CodeElement>();
@@ -203,7 +201,7 @@ public Invocation FindIncomingCallsRecursive(string id)
             }
         }
 
-        return new Invocation(foundMethods, foundCalls);
+        return new SearchResult(foundMethods, foundCalls);
     }
 
 
@@ -395,7 +393,6 @@ public SearchResult FindFullInheritanceTree(string id)
         {
             var typeToAnalyze = processingQueue.Dequeue();
             if (!processed.Add(typeToAnalyze.Id))
-                // Since we evaluate both direction in one iteration, an already processed node is added again.
             {
                 continue;
             }
@@ -457,19 +454,19 @@ d.Type is RelationshipType.Overrides or RelationshipType.Inherits or Relationshi
     }
 
 
-    public Invocation FindOutgoingCalls(string id)
+    public SearchResult FindOutgoingCalls(string id)
     {
         ArgumentNullException.ThrowIfNull(id);
 
         if (_codeGraph is null || !_codeGraph.Nodes.TryGetValue(id, out var method))
         {
-            return new Invocation([], []);
+            return new SearchResult([], []);
         }
 
         var calls = method.Relationships
             .Where(d => d.Type == RelationshipType.Calls).ToList();
         var methods = calls.Select(m => _codeGraph.Nodes[m.TargetId]).ToList();
-        return new Invocation(methods, calls);
+        return new SearchResult(methods, calls);
     }
 
     public SearchResult FindOutgoingRelationships(string id)
@@ -520,48 +517,42 @@ public SearchResult FindGapsInHierarchy(HashSet<string> knownIds)
         return new SearchResult(elements, []);
     }
 
+
+    // Alternative implementation
     private HashSet<string> FillGapsInHierarchy(HashSet<string> knownIds)
     {
-        HashSet<string> newElementsIds = [];
-        var existing = knownIds.ToArray();
-        for (var i = 0; i < existing.Length; i++)
+        var added = new HashSet<string>();
+        if (_codeGraph is null)
         {
-            // We hit each pair twice so we walk only one direction here.
-            var possibleChild = _codeGraph!.Nodes[existing[i]];
+            return added;
+        }
 
-            for (var j = 0; j < existing.Length; j++)
+        foreach (var id in knownIds)
+        {
+            if (!_codeGraph.Nodes.TryGetValue(id, out var current))
             {
-                if (i == j)
-                {
-                    continue;
-                }
-
-                var possibleParent = _codeGraph.Nodes[existing[j]];
+                continue; // Skip invalid Id
+            }
 
-                // Only search for missing gaps if we have an ancestor relationship
-                if (!possibleChild.IsChildOf(possibleParent))
+            // Walk up until we reach a parent already known or run out.
+            while (current.Parent is not null && !knownIds.Contains(current.Parent.Id))
+            {
+                if (added.Add(current.Parent.Id))
                 {
-                    continue;
+                    current = current.Parent;
                 }
-
-                // Don't override possible child while climbing up.
-                var currentChild = possibleChild;
-                while (currentChild.Parent != null && currentChild.Id != possibleParent.Id)
+                else
                 {
-                    var parent = currentChild.Parent;
-                    if (!knownIds.Contains(parent.Id))
-                    {
-                        newElementsIds.Add(parent.Id);
-                    }
-
-                    currentChild = parent;
+                    // Already added
+                    current = current.Parent;
                 }
             }
         }
 
-        return newElementsIds;
+        return added;
     }
 
+
     /// <summary>
     ///     Returns all forbidden calls within the hierarchy.
     /// </summary>
@@ -735,6 +726,15 @@ void Collect(CodeElement c)
     }
 }
 
-public record struct SearchResult(IEnumerable<CodeElement> Elements, IEnumerable<Relationship> Relationships);
+public record struct SearchResult
+{
+    public SearchResult(IEnumerable<CodeElement> elements, IEnumerable<Relationship> relationships)
+    {
+        // Ensure query is executed only once
+        Elements = elements.ToList();
+        Relationships = relationships.ToList();
+    }
 
-public record struct Invocation(IEnumerable<CodeElement> Methods, IEnumerable<Relationship> Calls);
+    public IEnumerable<CodeElement> Elements { get; set; }
+    public IEnumerable<Relationship> Relationships { get; set; }
+}

CSharpCodeAnalyst/Exploration/ICodeGraphExplorer.cs

@@ -4,13 +4,13 @@ namespace CSharpCodeAnalyst.Exploration;
 
 public interface ICodeGraphExplorer
 {
-    Invocation FindIncomingCalls(string id);
-    Invocation FindOutgoingCalls(string id);
+    SearchResult FindIncomingCalls(string id);
+    SearchResult FindOutgoingCalls(string id);
 
     /// <summary>
     ///     Follows all incoming calls recursively.
     /// </summary>
-    Invocation FindIncomingCallsRecursive(string id);
+    SearchResult FindIncomingCallsRecursive(string id);
 
     /// <summary>
     ///     Traces back callers of the given method. Includes also abstractions and their callers