Async void helper (#3379)

Author: jamescrosswell

CHANGELOG.md

@@ -6,6 +6,10 @@
 
 - SentryOptions.EnableTracing has been marked as Obsolete ([#3381](https://github.com/getsentry/sentry-dotnet/pull/3381))
 
+### Features
+
+- Added an `SentrySdk.RunAsyncVoid` helper method that lets you capture exceptions from `async void` methods ([#3379](https://github.com/getsentry/sentry-dotnet/pull/3379))
+
 ### Fixes
 
 - P/Invoke warning for GetWindowThreadProcessId no longer shows when using Sentry in UWP applications ([#3372](https://github.com/getsentry/sentry-dotnet/pull/3372))

samples/Sentry.Samples.Maui/MainPage.xaml

@@ -70,6 +70,13 @@
                 Clicked="OnNativeCrashClicked"
                 HorizontalOptions="Center" />
 
+            <Button
+                x:Name="AsyncVoidCrashBtn"
+                Text="Capture an exception from an async void method"
+                SemanticProperties.Hint="Throws an exception in an async void event handler."
+                Clicked="OnAsyncVoidCrashClicked"
+                HorizontalOptions="Center" />
+
         </VerticalStackLayout>
     </ScrollView>
 

samples/Sentry.Samples.Maui/MainPage.xaml.cs

@@ -87,4 +87,27 @@ private void OnNativeCrashClicked(object sender, EventArgs e)
 #pragma warning restore CS0618
 #endif
     }
+
+    private void OnAsyncVoidCrashClicked(object sender, EventArgs e)
+    {
+        var client = new HttpClient(new FlakyMessageHandler());
+
+        // You can use RunAsyncVoid to call async methods safely from within MAUI event handlers.
+        SentrySdk.RunAsyncVoid(
+            async () => await client.GetAsync("https://amostunreliablewebsite.net/"),
+            ex => _logger.LogWarning(ex, "Error fetching data")
+        );
+
+        // This is an example of the same, omitting any exception handler callback. In this case, the default exception
+        // handler will be used, which simply captures any exceptions and sends these to Sentry
+        SentrySdk.RunAsyncVoid(async () => await client.GetAsync("https://amostunreliablewebsite.net/"));
+    }
+
+    private class FlakyMessageHandler : DelegatingHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request,
+            CancellationToken cancellationToken)
+            => throw new Exception();
+    }
 }

src/Sentry/Internal/ExceptionHandlingSynchronizationContext.cs

@@ -0,0 +1,23 @@
+namespace Sentry.Internal;
+
+/// <summary>
+/// See https://www.jamescrosswell.dev/posts/catching-async-void-exceptions/ for a detailed explanation
+/// </summary>
+internal class ExceptionHandlingSynchronizationContext(Action<Exception> exceptionHandler, SynchronizationContext? innerContext)
+    : SynchronizationContext
+{
+    public override void Post(SendOrPostCallback d, object? state)
+    {
+        if (state is ExceptionDispatchInfo exceptionInfo)
+        {
+            exceptionHandler(exceptionInfo.SourceException);
+            return;
+        }
+        if (innerContext != null)
+        {
+            innerContext.Post(d, state);
+            return;
+        }
+        base.Post(d, state);
+    }
+}

src/Sentry/SentrySdk.cs

@@ -679,6 +679,37 @@ public static void PauseSession()
     public static void ResumeSession()
         => CurrentHub.ResumeSession();
 
+    /// <summary>
+    /// Runs an `async void` method safely.
+    /// </summary>
+    /// <param name="task">Typically either a method group or an async lambda that executes some async void code</param>
+    /// <param name="handler">
+    /// An optional callback that will be run if an exception is thrown. If no callback is provided then by default the
+    /// exception will be captured and sent to Sentry.
+    /// </param>
+    /// <example>
+    /// <code>
+    /// SentrySdk.RunAsyncVoid(async () => await MyAsyncMethod(), ex => Console.WriteLine(ex.Message));
+    /// </code>
+    /// </example>
+    public static void RunAsyncVoid(Action task, Action<Exception>? handler = null)
+    {
+        var syncCtx = SynchronizationContext.Current;
+        try
+        {
+            handler ??= DefaultExceptionHandler;
+            SynchronizationContext.SetSynchronizationContext(new ExceptionHandlingSynchronizationContext(handler, syncCtx));
+            task();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(syncCtx);
+        }
+        return;
+
+        void DefaultExceptionHandler(Exception ex) => CaptureException(ex);
+    }
+
     /// <summary>
     /// Deliberately crashes an application, which is useful for testing and demonstration purposes.
     /// </summary>

test/Sentry.Tests/ApiApprovalTests.Run.DotNet6_0.verified.txt

@@ -806,6 +806,7 @@ namespace Sentry
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
         public static void ResumeSession() { }
+        public static void RunAsyncVoid(System.Action task, System.Action<System.Exception>? handler = null) { }
         public static void StartSession() { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context) { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet7_0.verified.txt

@@ -806,6 +806,7 @@ namespace Sentry
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
         public static void ResumeSession() { }
+        public static void RunAsyncVoid(System.Action task, System.Action<System.Exception>? handler = null) { }
         public static void StartSession() { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context) { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt

@@ -808,6 +808,7 @@ namespace Sentry
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
         public static void ResumeSession() { }
+        public static void RunAsyncVoid(System.Action task, System.Action<System.Exception>? handler = null) { }
         public static void StartSession() { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context) { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt

@@ -803,6 +803,7 @@ namespace Sentry
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
         public static void ResumeSession() { }
+        public static void RunAsyncVoid(System.Action task, System.Action<System.Exception>? handler = null) { }
         public static void StartSession() { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context) { }
         public static Sentry.ITransactionTracer StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }