Add recoverable UI-thread exception dialog

Register a Dispatcher.UnhandledException handler and add a recoverable exception dialog flow so UI-thread exceptions can offer a "continue" option instead of forcing an exit. Program.ShowExceptionDialog now accepts an isRecoverable flag, sets an appropriate Sentry mechanism, only flushes Sentry for non-recoverable crashes, and returns whether the user chose to continue. App marks exceptions handled when the user continues.

Author: ionite34

StabilityMatrix.Avalonia/App.axaml.cs

@@ -151,6 +151,11 @@ public override void OnFrameworkInitializationCompleted()
     {
         base.OnFrameworkInitializationCompleted();
 
+        if (!Debugger.IsAttached || Program.Args.DebugExceptionDialog)
+        {
+            Dispatcher.UIThread.UnhandledException += Dispatcher_UnhandledException;
+        }
+
         if (Design.IsDesignMode)
         {
             DesignData.DesignData.Initialize();
@@ -1015,6 +1020,14 @@ private static void OnServiceProviderDisposing(ServiceProvider serviceProvider)
         Logger.Trace("Disposing {Count} Disposables", disposables.Count);
     }
 
+    private static void Dispatcher_UnhandledException(object? sender, DispatcherUnhandledExceptionEventArgs e)
+    {
+        if (Program.ShowExceptionDialog(e.Exception, true))
+        {
+            e.Handled = true;
+        }
+    }
+
     private static void TaskScheduler_UnobservedTaskException(
         object? sender,
         UnobservedTaskExceptionEventArgs e

StabilityMatrix.Avalonia/Program.cs

@@ -69,8 +69,8 @@ public static void Main(string[] args)
             });
 
         if (
-            parseResult.Errors.Any(
-                x => x.Tag is ErrorType.HelpRequestedError or ErrorType.VersionRequestedError
+            parseResult.Errors.Any(x =>
+                x.Tag is ErrorType.HelpRequestedError or ErrorType.VersionRequestedError
             )
         )
         {
@@ -172,7 +172,7 @@ internal static void SetupAvaloniaApp()
             {
                 BaseCachePath = Path.Combine(Path.GetTempPath(), "StabilityMatrix", "Cache"),
                 CacheDuration = TimeSpan.FromDays(1),
-                MaxMemoryCacheCount = 100
+                MaxMemoryCacheCount = 100,
             }
         );
     }
@@ -198,7 +198,7 @@ public static AppBuilder BuildAvaloniaApp()
             app = app.With(
                 new Win32PlatformOptions
                 {
-                    RenderingMode = [Win32RenderingMode.Wgl, Win32RenderingMode.Software]
+                    RenderingMode = [Win32RenderingMode.Wgl, Win32RenderingMode.Software],
                 }
             );
         }
@@ -216,7 +216,7 @@ public static AppBuilder BuildAvaloniaApp()
                 .With(
                     new AvaloniaNativePlatformOptions
                     {
-                        RenderingMode = new[] { AvaloniaNativeRenderingMode.Software }
+                        RenderingMode = new[] { AvaloniaNativeRenderingMode.Software },
                     }
                 );
         }
@@ -402,14 +402,28 @@ private static void CurrentDomain_UnhandledException(object sender, UnhandledExc
         if (e.ExceptionObject is not Exception ex)
             return;
 
+        ShowExceptionDialog(ex, false);
+    }
+
+    internal static bool ShowExceptionDialog(Exception ex, bool isRecoverable)
+    {
         SentryId? sentryId = null;
 
         // Exception automatically logged by Sentry if enabled
         if (SentrySdk.IsEnabled)
         {
-            ex.SetSentryMechanism("AppDomain.UnhandledException", handled: false);
+            ex.SetSentryMechanism(
+                isRecoverable ? "Dispatcher.UnhandledException" : "AppDomain.UnhandledException",
+                handled: isRecoverable
+            );
+
             sentryId = SentrySdk.CaptureException(ex);
-            SentrySdk.FlushAsync().SafeFireAndForget();
+
+            if (!isRecoverable)
+            {
+                SentrySdk.FlushAsync().SafeFireAndForget();
+            }
+
             Logger.Warn(ex, "Unhandled {Type}: {Message}", ex.GetType().Name, ex.Message);
         }
         else
@@ -419,11 +433,15 @@ private static void CurrentDomain_UnhandledException(object sender, UnhandledExc
 
         if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime lifetime)
         {
-            var dialog = new ExceptionDialog
+            var viewModel = new ExceptionViewModel
             {
-                DataContext = new ExceptionViewModel { Exception = ex, SentryId = sentryId }
+                Exception = ex,
+                SentryId = sentryId,
+                IsRecoverable = isRecoverable,
             };
 
+            var dialog = new ExceptionDialog { DataContext = viewModel };
+
             // We can only show dialog if main window exists, and is visible
             if (lifetime.MainWindow is { PlatformImpl: not null, IsVisible: true } mainWindow)
             {
@@ -441,25 +459,38 @@ private static void CurrentDomain_UnhandledException(object sender, UnhandledExc
                         _ =>
                         {
                             cts.Cancel();
-                            ExitWithException(ex);
+                            if (!isRecoverable || !viewModel.IsContinueResult)
+                            {
+                                ExitWithException(ex);
+                            }
                         },
                         TaskScheduler.FromCurrentSynchronizationContext()
                     );
 
                 Dispatcher.UIThread.MainLoop(cts.Token);
+                return viewModel.IsContinueResult;
             }
             else
             {
                 // No parent window available
                 var cts = new CancellationTokenSource();
-                // Exit on token cancellation
-                cts.Token.Register(() => ExitWithException(ex));
+                // Exit on token cancellation only if not recoverable or user didn't choose continue
+                cts.Token.Register(() =>
+                {
+                    if (!isRecoverable || !viewModel.IsContinueResult)
+                    {
+                        ExitWithException(ex);
+                    }
+                });
 
                 dialog.ShowWithCts(cts);
 
                 Dispatcher.UIThread.MainLoop(cts.Token);
+                return viewModel.IsContinueResult;
             }
         }
+
+        return false;
     }
 
     [DoesNotReturn]