Xamarin.Forms - BeginInvokeOnMainThread for an async Action

Question

I am familiar with the rules about updating UI elements on the UI thread using the Device.BeginInvokeOnMainThread, however I have an operation that needs to be run on the UI thread that is actually a Task.

For example, the Push/PopAsync methods on XLabs.Forms.Mvvm seem to behave incorrectly on iOS unless they are invoked on the UI thread. There is also another example in the Acr.UserDialogs library for displaying toasts etc.

I know that making an Action async is basically creating an async void lambda and runs the risk of creating a deadlock in the case of an exception, obviously I don't want this to happen.

Does anybody have a workaround for performing async operations on the UI thread that doesn't involve marking the Action as async?

Answer 1

Just make sure you handle exceptions in your Action and you should be fine. The problem you described occurs when you don't handle the exceptions. Below is a very simple example of running an async method from the main thread.

private void Test()
{
    Device.BeginInvokeOnMainThread(SomeMethod);
}

private async void SomeMethod()
{
    try
    {
        await SomeAsyncMethod();
    }
    catch (Exception e) // handle whatever exceptions you expect
    {
        //Handle exceptions
    }
}

private async Task SomeAsyncMethod()
{
    await Navigation.PushModalAsync(new ContentPage());
}

Answer 2

Since Xamarin.Forms 4.2 there is now a helper method to run tasks on the main thread and await them.

await Device.InvokeOnMainThreadAsync(SomeAsyncMethod);

Several overloads exist that should cover most scenarios:

System.Threading.Tasks.Task InvokeOnMainThreadAsync (System.Action action);
System.Threading.Tasks.Task InvokeOnMainThreadAsync (System.Func<System.Threading.Tasks.Task> funcTask);
System.Threading.Tasks.Task<T> InvokeOnMainThreadAsync<T> (System.Func<System.Threading.Tasks.Task<T>> funcTask);
System.Threading.Tasks.Task<T> InvokeOnMainThreadAsync<T> (System.Func<T> func);

Related PR: https://github.com/xamarin/Xamarin.Forms/pull/5028

NOTE: the PR had some bug that was fixed in v4.2, so don't use this in v4.1.

Answer 3

Dropping this here in case someone wants to await the end of an action which has to be executed on the main thread

public static class DeviceHelper
{
    public static Task RunOnMainThreadAsync(Action action)
    {
        var tcs = new TaskCompletionSource<object>();
        Device.BeginInvokeOnMainThread(
            () =>
            {
                try
                {
                    action();
                    tcs.SetResult(null);
                }
                catch (Exception e)
                {
                    tcs.SetException(e);
                }
            });

        return tcs.Task;
    }

    public static Task RunOnMainThreadAsync(Task action)
    {
        var tcs = new TaskCompletionSource<object>();
        Device.BeginInvokeOnMainThread(
            async () =>
            {
                try
                {
                    await action;
                    tcs.SetResult(null);
                }
                catch (Exception e)
                {
                    tcs.SetException(e);
                }
            });

        return tcs.Task;
    }
}

Answer 4

Evaluating the Maui framework and the related WeatherTwentyOne demo. The dialogs were throwing exceptions on Android 29 related to auth modifications. Hat tip to this post Why does my app crash after alert dialog buttons are clicked

Anyway, I could not locate the aforementioned async helpers. So I adapted @Dbl's post to include awaitable generic results (or not)

using System;
using System.Threading.Tasks;
using Microsoft.Maui.Controls;

// ReSharper disable AsyncVoidLambda

namespace WeatherTwentyOne.Utils
{
    public static class DeviceHelper
    {
        // https://stackoverflow.com/a/47941859/241296

        public static Task<T> RunOnMainThreadAsync<T>(Func<Task<T>> op)
        {
            var tcs = new TaskCompletionSource<T>();
            Device.BeginInvokeOnMainThread(async
                () => {
                try
                {
                    var t = await op();
                    tcs.SetResult(t);
                }
                catch (Exception e)
                {
                    tcs.SetException(e);
                }
            });

            return tcs.Task;
        }

        public static Task RunOnMainThreadAsync(Func<Task> op)
        {
            var tcs = new TaskCompletionSource();
            Device.BeginInvokeOnMainThread(async
                () => {
                try
                {
                    await op();
                    tcs.SetResult();
                }
                catch (Exception e)
                {
                    tcs.SetException(e);
                }
            });

            return tcs.Task;
        }
    }
}

Example usage:

var password = await Utils.DeviceHelper.RunOnMainThreadAsync<string>(async () => await DisplayPromptAsync("Login", "Enter password"));

Edit: 2022-03-26

In response to the following warning:

   BeginInvokeOnMainThread(Action) is obsolete: Use BindableObject.Dispatcher.Dispatch() instead

implementation revised to:

public static class DeviceHelper
{

  public static Task<T> RunOnMainThreadAsync<T>(Func<Task<T>> op)
  {
    var tcs = new TaskCompletionSource<T>();

    Application.Current?.Dispatcher.Dispatch(async () =>
    {
      try
      {
        var t = await op();
        tcs.SetResult(t);
      }
      catch (Exception e)
      {
        tcs.SetException(e);
      }
    });

    return tcs.Task;
  }

  public static Task RunOnMainThreadAsync(Func<Task> op)
  {
    var tcs = new TaskCompletionSource();

    Application.Current?.Dispatcher.Dispatch(async () =>
    {
      try
      {
        await op();
        tcs.SetResult();
      }
      catch (Exception e)
      {
        tcs.SetException(e);
      }
    });

    return tcs.Task;
  }
}