Trigger Async Function on Other Pages by Calling it in Non-Async Constructor in C#

Issue

In my App, there is an Async Function ProcessOffer(). When I called it in Constructor as ProcessOffer, it works but synchronously. I want to call this Function in constructor asynchronously.

The ProcessOffer() is a function implemented in CredentialViewModel, but I want that, It should be triggered asynchronously everywhere on the App (IndexViewModel e.t.c).

If I'm on the IndexPage, and Web Application sends a request to Mobile Application, ProcessOffer(), should be triggered.. actually what ProcessOffer does is, that it asks the user to enter a PIN, if it's correct, it sends back a response to the Web Application.

I've tried answers from other Posts, but they returned the Error Autofac.Core.DependencyResolutionException: 'An exception was thrown while activating App.Name, when I sends a request to Mobile App from Web Application.

The Solutions I tried.

1- https://stackoverflow.com/a/64012442/14139029

2- Task.Run(() => ProcessOffer()).Wait();

3- ProcessOffer().GetAwatier().GetResult();

CredentialViewModel.cs

namespace Osma.Mobile.App.ViewModels.Credentials
{
    public class CredentialViewModel : ABaseViewModel
    {
        private readonly CredentialRecord _credential;
        private readonly ICredentialService _credentialService;
        private readonly IAgentProvider _agentContextProvider;
        private readonly IConnectionService _connectionService;
        private readonly IMessageService _messageService;
        private readonly IPoolConfigurator _poolConfigurator;

        [Obsolete]
        public CredentialViewModel(
            IUserDialogs userDialogs,
            INavigationService navigationService,
            ICredentialService credentialService,
            IAgentProvider agentContextProvider,
            IConnectionService connectionService,
            IMessageService messageService,
            IPoolConfigurator poolConfigurator,
            CredentialRecord credential
        ) : base(
            nameof(CredentialViewModel),
            userDialogs,
            navigationService
        )
        {
            _credential = credential;
            _credentialService = credentialService;
            _agentContextProvider = agentContextProvider;
            _connectionService = connectionService;
            _messageService = messageService;
            _poolConfigurator = poolConfigurator;

            _credentialState = _credential.State.ToString();

            if (_credentialState == "Offered")
            {
                ProcessOffer();
            }
        }

        [Obsolete]
        public async Task ProcessOffer()
        {

            foreach (var item in _credential.CredentialAttributesValues)
            {
                await SecureStorage.SetAsync(item.Name.ToString(), item.Value.ToString());
            }

            var RegisteredPIN = await SecureStorage.GetAsync("RegisteredPIN");
            string PIN = await App.Current.MainPage.DisplayPromptAsync("Enter PIN", null, "Ok", "Cancel", null, 6, Keyboard.Numeric);
            if (PIN == RegisteredPIN)
            {
                try
                {
                    //await _poolConfigurator.ConfigurePoolsAsync();
                    var agentContext = await _agentContextProvider.GetContextAsync();
                    var credentialRecord = await _credentialService.GetAsync(agentContext, _credential.Id);
                    var connectionId = credentialRecord.ConnectionId;
                    var connectionRecord = await _connectionService.GetAsync(agentContext, connectionId);
                    (var request, _) = await _credentialService.CreateRequestAsync(agentContext, _credential.Id);
                    await _messageService.SendAsync(agentContext.Wallet, request, connectionRecord);
                    await DialogService.AlertAsync("Request has been sent to the issuer.", "Success", "Ok");
                }
                catch (Exception e)
                {
                    await DialogService.AlertAsync(e.Message, "Error", "Ok");
                }
            }
            else if (PIN != RegisteredPIN && PIN != null)
            {
                DialogService.Alert("Provided PIN is not correct");
            }
        }

        #region Bindable Command
        [Obsolete]
        public ICommand ProcessOfferCommand => new Command(async () => await ProcessOffer());

        public ICommand NavigateBackCommand => new Command(async () =>
        {
            await NavigationService.PopModalAsync();
        });
        #endregion

        #region Bindable Properties
        private string _credentialState;
        public string CredentialState
        {
            get => _credentialState;
            set => this.RaiseAndSetIfChanged(ref _credentialState, value);
        }
        #endregion
    }
}

IndexViewModel.cs

namespace Osma.Mobile.App.ViewModels.Index
{
    public class IndexViewModel : ABaseViewModel
    {
        private readonly IConnectionService _connectionService;
        private readonly IMessageService _messageService;
        private readonly IAgentProvider _agentContextProvider;
        private readonly IEventAggregator _eventAggregator;
        private readonly ILifetimeScope _scope;

        public IndexViewModel(
            IUserDialogs userDialogs,
            INavigationService navigationService,
            IConnectionService connectionService,
            IMessageService messageService,
            IAgentProvider agentContextProvider,
            IEventAggregator eventAggregator,
            ILifetimeScope scope
            ) : base(
                "Index",
                userDialogs,
                navigationService
           )
        {
            _connectionService = connectionService;
            _messageService = messageService;
            _agentContextProvider = agentContextProvider;
            _eventAggregator = eventAggregator;
            _scope = scope;
        }

        public override async Task InitializeAsync(object navigationData)
        {
            await base.InitializeAsync(navigationData);
        }

        public class Post
        {
            public string Success { get; set; }
            public string firstname { get; set; }
        }

        [Obsolete]
        public async Task ScanVerification(object sender, EventArgs e)
        {
            // Code
        }

        public async Task SettingsPage(SettingsViewModel settings) => await NavigationService.NavigateToAsync(settings, null, NavigationType.Modal);

        #region Bindable Command
        public ICommand SettingsPageCommand => new Command<SettingsViewModel>(async (settings) =>
        {
                await SettingsPage(settings);
        });

        [Obsolete]
        public ICommand ScanVerificationCommand => new Command(async () => await ScanVerification(default, default));
        #endregion
    }
}

App.xml.cs

[assembly: XamlCompilation(XamlCompilationOptions.Compile)]
namespace Osma.Mobile.App
{
    public partial class App : Application
    {
        public new static App Current => Application.Current as App;
        public static IContainer Container { get; set; }

        // Timer to check new messages in the configured mediator agent every 10sec
        private readonly Timer timer;
        private static IHost Host { get; set; }

        public App()
        {
            InitializeComponent();

            timer = new Timer
            {
                Enabled = false,
                AutoReset = true,
                Interval = TimeSpan.FromSeconds(10).TotalMilliseconds
            };
            timer.Elapsed += Timer_Elapsed;
        }

        public App(IHost host) : this() => Host = host;

        public static IHostBuilder BuildHost(Assembly platformSpecific = null) =>
            XamarinHost.CreateDefaultBuilder<App>()
                .ConfigureServices((_, services) =>
                {
                    services.AddAriesFramework(builder => builder.RegisterEdgeAgent(
                        options: options =>
                        {
                            options.AgentName = "Mobile Holder";
                            options.EndpointUri = "http://11.222.333.44:5000";

                            options.WalletConfiguration.StorageConfiguration =
                                new WalletConfiguration.WalletStorageConfiguration
                                {
                                    Path = Path.Combine(
                                        path1: FileSystem.AppDataDirectory,
                                        path2: ".indy_client",
                                        path3: "wallets")
                                };
                            options.WalletConfiguration.Id = "MobileWallet";
                            options.WalletCredentials.Key = "SecretWalletKey";
                            options.RevocationRegistryDirectory = Path.Combine(
                                path1: FileSystem.AppDataDirectory,
                                path2: ".indy_client",
                                path3: "tails");

                            // Available network configurations (see PoolConfigurator.cs):
                            options.PoolName = "sovrin-test";
                        },
                        delayProvisioning: true));

                    services.AddSingleton<IPoolConfigurator, PoolConfigurator>();

                    var containerBuilder = new ContainerBuilder();
                    containerBuilder.RegisterAssemblyModules(typeof(CoreModule).Assembly);
                    if (platformSpecific != null)
                    {
                        containerBuilder.RegisterAssemblyModules(platformSpecific);
                    }

                    containerBuilder.Populate(services);
                    Container = containerBuilder.Build();
                });

        protected override async void OnStart()
        {
            await Host.StartAsync();

            // View models and pages mappings
            var _navigationService = Container.Resolve<INavigationService>();
            _navigationService.AddPageViewModelBinding<MainViewModel, MainPage>();
            _navigationService.AddPageViewModelBinding<RegisterViewModel, RegisterPage>();
            _navigationService.AddPageViewModelBinding<IndexViewModel, IndexPage>();
            _navigationService.AddPageViewModelBinding<SettingsViewModel, SettingsPage>();
            _navigationService.AddPageViewModelBinding<CredentialsViewModel, CredentialsPage>();
            _navigationService.AddPageViewModelBinding<CredentialViewModel, CredentialPage>();

            if (Preferences.Get(AppConstant.LocalWalletProvisioned, false))
            {
                await _navigationService.NavigateToAsync<MainViewModel>();
            }
            else
            {
                await _navigationService.NavigateToAsync<ProviderViewModel>();
            }

            timer.Enabled = true;
        }

        private void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            // Check for new messages with the mediator agent if successfully provisioned
            if (Preferences.Get(AppConstant.LocalWalletProvisioned, false))
            {
                Device.BeginInvokeOnMainThread(async () =>
                {
                    try
                    {
                        var context = await Container.Resolve<IAgentProvider>().GetContextAsync();
                        await Container.Resolve<IEdgeClientService>().FetchInboxAsync(context);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex);
                    }
                });
            }
        }
        protected override void OnSleep() =>
            // Stop timer when application goes to background
            timer.Enabled = false;

        protected override void OnResume() =>
            // Resume timer when application comes in foreground
            timer.Enabled = true;
    }
}

Solution

So in my View Models, if i need to initialize asynchronously I usually pass OnAppearing() to the view model instead of the constructor. Someone can tell me if this is unwise but it solved my needs.

Code Behind View:

[XamlCompilation(XamlCompilationOptions.Compile)]
public partial class CredentialView : ContentPage
{
    public CredentialView()
    {
        InitializeComponent();
        BindingContext = new CredentialViewModel();
    }

    protected override void OnAppearing()
    {
        base.OnAppearing();
        ((CredentialViewModel)BindingContext).OnAppearing();
    }
}

View Model:

public class CredentialViewModel : INotifyPropertyChanged
{

    public CredentialViewModel ()
    {
    }

    public async void OnAppearing()
    {
        await ProcessOffer();
    }

 }

Also just FYI, the biggest gotcha i've experienced with asynchronous code on xamarin is to use BeginInvokeOnMainThread. It's my understanding that touched UI should be executed on main thread! (probably why they call it the UI thread. haha) Example:

Device.BeginInvokeOnMainThread(() =>
{
    observableCollection.Clear();
});

Answered By - Solarcloud