Allow partial loading of solutions if some projects fail

Author: ATrefzer

CSharpCodeAnalyst/MainViewModel.cs

@@ -4,7 +4,6 @@
 using System.Globalization;
 using System.IO;
 using System.Reflection;
-using System.Runtime;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Windows;
@@ -36,6 +35,7 @@ namespace CSharpCodeAnalyst;
 
 internal class MainViewModel : INotifyPropertyChanged
 {
+    private readonly int _maxDegreeOfParallelism;
     private readonly MessageBus _messaging;
 
     private readonly ProjectExclusionRegExCollection _projectExclusionFilters;
@@ -58,6 +58,8 @@ internal class MainViewModel : INotifyPropertyChanged
     private string _loadMessage;
     private ObservableCollection<IMetric> _metrics = [];
 
+    private LegendDialog? _openedLegendDialog;
+
     private List<QuickInfo> _quickInfo = QuickInfoFactory.NoInfoProviderRegistered;
     private int _selectedTabIndex;
 
@@ -319,16 +321,13 @@ GraphSession AddSession(string name)
         }
     }
 
-    LegendDialog? _openedLegendDialog;
-    private readonly int _maxDegreeOfParallelism;
-
     private void ShowLegend()
     {
         if (_openedLegendDialog == null)
         {
             _openedLegendDialog = new LegendDialog();
             _openedLegendDialog.Owner = Application.Current.MainWindow;
-            _openedLegendDialog.Closed += (object? sender, EventArgs e) => _openedLegendDialog = null;
+            _openedLegendDialog.Closed += (sender, e) => _openedLegendDialog = null;
             _openedLegendDialog.Show();
         }
     }
@@ -509,7 +508,14 @@ private async Task LoadAndAnalyzeSolution(string solutionPath)
         {
             IsLoading = true;
 
-            var codeGraph = await Task.Run(async () => await LoadAsync(solutionPath));
+            var (codeGraph, diagnostics) = await Task.Run(async () => await LoadAsync(solutionPath));
+
+            var failures = diagnostics.FormatFailures();
+            if (string.IsNullOrEmpty(failures) is false)
+            {
+                var failureText = Strings.Parser_FailureHeader + failures;
+                MessageBox.Show(failureText, Strings.Error_Title, MessageBoxButton.OK, MessageBoxImage.Warning);
+            }
 
             LoadCodeGraph(codeGraph);
 
@@ -529,15 +535,15 @@ private async Task LoadAndAnalyzeSolution(string solutionPath)
         }
     }
 
-    private async Task<CodeGraph> LoadAsync(string solutionPath)
+    private async Task<(CodeGraph, IParserDiagnostics)> LoadAsync(string solutionPath)
     {
         LoadMessage = "Loading ...";
         var parser = new Parser(new ParserConfig(_projectExclusionFilters, _maxDegreeOfParallelism));
         parser.Progress.ParserProgress += OnProgress;
         var graph = await parser.ParseSolution(solutionPath).ConfigureAwait(true);
 
         parser.Progress.ParserProgress -= OnProgress;
-        return graph;
+        return (graph, parser.Diagnostics);
     }
 
     private void LoadCodeGraph(CodeGraph codeGraph)

CSharpCodeAnalyst/Resources/Strings.Designer.cs

@@ -414,4 +414,9 @@
   <data name="Legend_Tooltip" xml:space="preserve">
     <value>Show color legend</value>
   </data>
+  <data name="Parser_FailureHeader" xml:space="preserve">
+    <value>There are failures when loading the solution. The code graph may not complete:
+
+</value>
+  </data>
 </root>

CSharpCodeAnalyst/Resources/Strings.resx

@@ -1,6 +1,8 @@
 using System.Diagnostics;
 using CodeParser.Parser.Config;
+using Contracts.Common;
 using Contracts.Graph;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.MSBuild;
 
 namespace CodeParser.Parser;
@@ -15,16 +17,22 @@ public class Parser(ParserConfig config)
 {
     public Progress Progress { get; set; } = new();
 
+    private readonly ParserDiagnostics _diagnostics = new ParserDiagnostics();
+
+    public IParserDiagnostics Diagnostics => _diagnostics;
+
     public async Task<CodeGraph> ParseSolution(string solutionPath)
     {
+        _diagnostics.Clear();
+
         var sw = Stopwatch.StartNew();
 
         Progress.SendProgress("Compiling ...");
 
         var workspace = MSBuildWorkspace.Create();
         workspace.WorkspaceFailed += Workspace_WorkspaceFailed;
         var solution = await workspace.OpenSolutionAsync(solutionPath);
-        
+
 
         sw.Stop();
         Trace.WriteLine("Compiling: " + sw.Elapsed);
@@ -56,12 +64,10 @@ public async Task<CodeGraph> ParseSolution(string solutionPath)
         return codeGraph;
     }
 
-    private void Workspace_WorkspaceFailed(object? sender, Microsoft.CodeAnalysis.WorkspaceDiagnosticEventArgs e)
+    private void Workspace_WorkspaceFailed(object? sender, WorkspaceDiagnosticEventArgs e)
     {
-        if (e.Diagnostic.Kind == Microsoft.CodeAnalysis.WorkspaceDiagnosticKind.Failure)
-        { 
-            throw new InvalidOperationException(e.Diagnostic.Message); 
-        }
+        _diagnostics.Add(e.Diagnostic);
+        Trace.WriteLine(e.Diagnostic.Message);
     }
 
     private bool IsDistinct<T>(List<T> collection)

CodeParser/Parser/Parser.cs

@@ -0,0 +1,31 @@
+using Contracts.Common;
+using Microsoft.CodeAnalysis;
+
+namespace CodeParser.Parser;
+
+internal class ParserDiagnostics : IParserDiagnostics
+{
+    public List<WorkspaceDiagnostic> Diagnostics { get; } = new();
+
+    public string FormatFailures()
+    {
+        var failures = Diagnostics.Where(d => d.Kind == WorkspaceDiagnosticKind.Failure).Select(d => d.Message);
+        return string.Join(Environment.NewLine, failures);
+    }
+
+    public string FormatWarnings()
+    {
+        var failures = Diagnostics.Where(d => d.Kind == WorkspaceDiagnosticKind.Warning).Select(d => d.Message);
+        return string.Join(Environment.NewLine, failures);
+    }
+
+    public void Add(WorkspaceDiagnostic diagnostic)
+    {
+        Diagnostics.Add(diagnostic);
+    }
+
+    public void Clear()
+    {
+        Diagnostics.Clear();
+    }
+}

CodeParser/Parser/ParserDiagnostics.cs

@@ -0,0 +1,7 @@
+namespace Contracts.Common;
+
+public interface IParserDiagnostics
+{
+    string FormatFailures();
+    string FormatWarnings();
+}