Confusion regarding VSTHRD100 and VSTHRD110 for event handlers

[prlcutting]

VSTHRD100 Avoid async void methods suggests that async void should be avoided, and to use the following pattern instead:

private void HandleEvent(object sender, EventArgs e)
{
    _ = joinableTaskFactory.RunAsync(async () =>
    {
       // async code
    });
}

Note the use of the discard for the JoinableTask returned from the RunAsync method. If the discard is removed, it produces VSTHRD110 Observe result of async calls, which makes sense. What makes it "okay" to use a discard here to silence VSTHRD110?

Either way (discard or no discard), doesn't this mean that any exceptions will go unobserved, and will (eventually) result in a UnobservedTaskException at some indeterminate time in the future whenever a garbage collection occurs?

private void HandleEvent(object sender, EventArgs e)
{
    // Task is not awaited, so exception is not observed.
    _joinableTaskFactory.RunAsync(async () =>
    {
        // Task is awaited, so exception is observed.
        // It "rolls up" to the outer Task.
        await ThrowExceptionAsync();
    });
}

In the above scenario, when ThrowExceptionAsync throws an exception, it will go unobserved. That seems problematic. Is this "less bad" than using async void where the exception is immediately observed, at the expense of crashing the application if not handled I guess?

Why does VSTHRD100 Avoid async void methods suggest using JoinableTaskFactory.RunAsync rather than JoinableTaskFactory.Run? The latter seems like a more natural fit for a non-async method like an event handler, with the caveat that we've found we've sometimes run into deadlock situations using it with more complex code.

Also, VSTHRD100 Avoid async void methods suggests referring to Async/Await - Best Practices in Asynchronous Programming by Stephen Cleary which seems to directly contradict VSTHRD100, in that event handlers are an exception to the rule of "avoid async void", and that you should use async void for them (generally). This is confusing.

I guess I'm fumbling around somewhat and trying to develop an understanding of what the best practices are so that I can communicate them to my team, and I'm finding I'm chasing my tail a bit with some of the analyzers, and the documentation is in some cases confusing/contradictory.

In another discussion it was mentioned that for new WPF apps, JoinableTaskFactory shouldn't be needed because you should be async from the start. While a worthy goal, I'm not sure how you fully achieve that when the language and technology push/force you into anti-patterns, e.g., event handlers that require a void signature, WPF requiring updates to happen on the main UI thread, etc.

Any advice would be appreciated, thanks.

In case it helps, I've included a small, crude WPF app using .NET 8 that demonstrates various scenarios for event handlers and exception handling, some of which are discussed above. Note that you'll have to comment out all scenarios but one to run it.

MainWindow.xaml

<Window
    x:Class="JoinableTaskFactoryRunAsync.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:JoinableTaskFactoryRunAsync"
    mc:Ignorable="d"
    Title="MainWindow"
    WindowStartupLocation="CenterScreen"
    Height="450"
    Width="800">

    <Grid
        Margin="10">

        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="20"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <StackPanel
            Grid.Row="0"
            Orientation="Vertical"
            VerticalAlignment="Center">

            <Button
                x:Name="ThrowExceptionButton"
                Content="Throw exception"
                Width="120"
                Height="30"
                Margin="0,0,0,20"/>

            <Button
                x:Name="GCCollectButton"
                Content="GC.Collect"
                Width="120"
                Height="30"/>
        </StackPanel>

        <TextBox
            Grid.Row="2"
            x:Name="OutputTextBlock"
            IsReadOnly="True"
            TextWrapping="Wrap"
            ScrollViewer.HorizontalScrollBarVisibility="Disabled"
            ScrollViewer.VerticalScrollBarVisibility="Auto"/>
    </Grid>
</Window>

MainWindow.xaml.cs

using System;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Microsoft.VisualStudio.Threading;

namespace JoinableTaskFactoryRunAsync;

public partial class MainWindow : Window
{
    private static readonly JoinableTaskContext _joinableTaskContext = new();

    private readonly JoinableTaskFactory _joinableTaskFactory =
        _joinableTaskContext.Factory;

    public MainWindow()
    {
        InitializeComponent();

        ThrowExceptionButton.Click +=
            OnThrowExceptionButtonClick;

        GCCollectButton.Click +=
            OnGCCollectButtonClick;

        Application.Current.Dispatcher.UnhandledException +=
            OnDispatcherUnhandledException;

        TaskScheduler.UnobservedTaskException +=
            OnTaskSchedulerUnobservedTaskException;

        AppDomain.CurrentDomain.UnhandledException +=
            OnCurrentDomainUnhandledException;
    }

    // Scenario 1: CS4014: Normal void event handler. Task not awaited.
    private void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // Task is not awaited, so exception is not observed.
        ThrowExceptionAsync();
    }

    // Scenario 2: VSTHRD100: async void event handler.
    private async void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // Task is awaited, so exception is observed.
        await ThrowExceptionAsync();
    }

    // Scenario 3: JTF.Run.
    private void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        _joinableTaskFactory.Run(async () =>
        {
            // Task is awaited, so exception is observed.
            await ThrowExceptionAsync();
        });
    }

    // Scenario 4: JTF.RunAsync w/o discard. Task not awaited.
    private void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // Task is not awaited, so exception is not observed.
        _joinableTaskFactory.RunAsync(async () =>
        {
            // Task is awaited, so exception is observed.
            await ThrowExceptionAsync();
        });
    }

    // Scenario 5: JTF.RunAsync w/ discard. Task not awaited.
    private void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // Task is not awaited, so exception is not observed.
        _ = _joinableTaskFactory.RunAsync(async () =>
        {
            // Task is awaited, so exception is observed.
            await ThrowExceptionAsync();
        });
    }

    // Scenario 6: VSTHRD100: async void event handler.
    // JTF.RunAsync w/ Task variable. Task is awaited and exception handled.
    private async void OnThrowExceptionButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // Task is not awaited, so exception is not observed.
        var task = _joinableTaskFactory.RunAsync(async () =>
        {
            // Task is awaited, so exception is observed.
            await ThrowExceptionAsync();
        });

        try
        {
            // Task is awaited, so exception is observed.
            await task;
        }
        catch (InvalidOperationException ex)
        {
            await ProcessExceptionAsync(
                ex,
                nameof(InvalidOperationException));
        }
    }

    private void OnGCCollectButtonClick(
        object sender,
        RoutedEventArgs e)
    {
        // This will force any unobserved task exceptions to be rethrown by the
        // finalizer thread. The TaskScheduler.UnobservedTaskException event
        // will be raised.
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }

    private void OnDispatcherUnhandledException(
        object sender,
        DispatcherUnhandledExceptionEventArgs e)
    {
        ProcessException(
            e.Exception,
            nameof(Application.Current.Dispatcher.UnhandledException));

        e.Handled = true;
    }

    private void OnTaskSchedulerUnobservedTaskException(
        object? sender,
        UnobservedTaskExceptionEventArgs e)
    {
        ProcessException(
            e.Exception,
            nameof(TaskScheduler.UnobservedTaskException));

        e.SetObserved();
    }

    private void OnCurrentDomainUnhandledException(
        object sender,
        UnhandledExceptionEventArgs e)
    {
        ProcessException(
            (Exception)e.ExceptionObject,
            nameof(AppDomain.CurrentDomain.UnhandledException));
    }

    private void ProcessException(
        Exception ex,
        string source)
    {
        _ = _joinableTaskFactory.RunAsync(async () =>
        {
            await ProcessExceptionAsync(ex, source);
        });
    }

    private async Task ProcessExceptionAsync(
        Exception ex,
        string source)
    {
        await _joinableTaskFactory.SwitchToMainThreadAsync();

        OutputTextBlock.Text = $"{OutputTextBlock.Text}\n{source}\n\n{ex}".Trim();
    }

    private async Task ThrowExceptionAsync()
    {
        OutputTextBlock.Text = string.Empty;

        await Task.Yield().ConfigureAwait(false);
        throw new InvalidOperationException("Boom!");
    }
}