[HELP] How to support async functions with ProgressDialog.

[nlogozzo]

Hi I have a ProgressDialogService meant to take an async function and run it in the ProgressDialog as some async functions take some time.

using Ookii.Dialogs.Wpf;
using System;
using System.ComponentModel;
using System.Threading.Tasks;

namespace Nickvision.WPF.MVVM.Services
{
    /// <summary>
    /// A service that contains methods for working with Progress Dialogs
    /// </summary>
    public class ProgressDialogService : IProgressDialogService
    {
        private Func<Task> _toExecute;

        /// <summary>
        /// Shows a progress dialog
        /// </summary>
        /// <param name="description">The description of the task</param>
        /// <param name="task">The async task</param>
        public void ShowDialog(string description, Func<Task> task)
        {
            using var progressDialog = new ProgressDialog()
            {
                WindowTitle = "Progress Dialog",
                Text = description,
                Description = "Please Wait...",
                ShowTimeRemaining = true,
                ShowCancelButton = false
            };
            _toExecute = task;
            progressDialog.DoWork += DoWork;
            progressDialog.ShowDialog();
        }

        /// <summary>
        /// Executes a command
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">DoWorkEventArgs</param>
        public async void DoWork(object sender, DoWorkEventArgs e) => await DoWorkAsync(sender, e);

        /// <summary>
        /// Executes a command asynchronously
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">DoWorkEventArgs</param>
        /// <returns></returns>
        public async Task DoWorkAsync(object sender, DoWorkEventArgs e) => await _toExecute();
    }
}

However, when I try to show the dialog I get no error and no dialog shows up:

private void Button_Click(object sender, RoutedEventArgs e)
        {
            var prog = new ProgressDialogService();
            prog.ShowDialog("Testing...", async () => await Task.Delay(10000));
        }

Any ideas?

[augustoproiete]

Hey @nlogozzo, the code in the DoWork event handler runs inside of a BackgroundWorker on a separate thread, so you're free to block this thread as it won't impact / freeze the UI... In other words, you don't need to await.

i.e. You could block on the GetResult of the awaiter:

private void DoWork(object sender, DoWorkEventArgs e) => _toExecute()
    .ConfigureAwait(false)
    .GetAwaiter()
    .GetResult();

Note that you shouldn't need to call DoWork from the outside (i.e. it should be private) because your ShowDialog calls the ShowDialog of the ProgressDialog which will cause the task to run.

You also shouldn't need the DoWorkAsync method at all, for the same reason above.

[nlogozzo]

Ok so I have implemented the following code

/// <summary>
    /// A service that contains methods for working with Progress Dialogs
    /// </summary>
    public class ProgressDialogService : IProgressDialogService
    {
        private Func<Task> _toExecute;

        /// <summary>
        /// Shows a progress dialog
        /// </summary>
        /// <param name="description">The description of the task</param>
        /// <param name="task">The async task</param>
        public void ShowDialog(string description, Func<Task> task)
        {
            using var progressDialog = new ProgressDialog()
            {
                WindowTitle = "Progress Dialog",
                Text = description,
                Description = "Please Wait...",
                ShowTimeRemaining = true,
                ShowCancelButton = false
            };
            _toExecute = task;
            progressDialog.DoWork += DoWork;
            progressDialog.ShowDialog();
        }

        /// <summary>
        /// Executes a command
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">DoWorkEventArgs</param>
        private void DoWork(object sender, DoWorkEventArgs e) => _toExecute().ConfigureAwait(false).GetAwaiter().GetResult();
    }

And I show the dialog by using:

private void Button_Click(object sender, RoutedEventArgs e)
        {
            var prog = new ProgressDialogService();
            prog.ShowDialog("Testing...", () =>  Task.Delay(10000));
        }

However, the dialog does show and the task does occur, however the progress bar does not update.

The progress bar is blank till about a second before the task completes and then the progress bar runs for a second and the window closes

[nlogozzo]

Fixed by adding ProgressBarStyle = ProgressBarStyle.MarqueeProgressBar to the ProgressDialog

[augustoproiete]

@nlogozzo MarqueeProgressBar is a style that is intermittent, and doesn't really show incremental progress.

You're supposed to call progressDialog.ReportProgress with a number between 0 and 100 as you execute your task, to make the progress bar move.

e.g.

progressDialog.ReportProgress(x, null, $"Processing: {x}%");

There is an example of usage of all dialogs in the Sample project. For the ProgressDialog look for _sampleProgressDialog

[nlogozzo]

Yeah I want the progress dialog to be intermittent as it just executes an asynchronous task and calls it a day ... no need to report progress, just show something is happening and when it’s done, it’s done --Project I'm using this with: https://github.com/nlogozzo/Nickvision.WPF

…

On Apr 17, 2021, at 5:14 PM, C. Augusto Proiete ***@***.***> wrote:  @nlogozzo MarqueeProgressBar is a style that is intermittent, and doesn't really show incremental progress. You're supposed to call progressDialog.ReportProgress with a number between 0 and 100 as you execute your task, to make the progress bar move. e.g. progressDialog.ReportProgress(x, null, $"Processing: {x}%"); There is an example of usage of all dialogs in the Sample project. For the ProgressDialog look for _sampleProgressDialog — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub, or unsubscribe.

[nlogozzo]

Hey @augustoproiete. For some reason it's not working correctly.

Here is my service implementation

/// <summary>
        /// Shows a progress dialog
        /// </summary>
        /// <param name="description">The description of the task</param>
        /// <param name="task">The async task</param>
        /// <param name="configureAwait">The bool to pass to the Task's ConfigureAwait method</param>
        public void ShowDialog(string description, Func<Task> task, bool configureAwait = true)
        {
            using var progressDialog = new ProgressDialog()
            {
                WindowTitle = "Progress Dialog",
                Text = description,
                Description = "Please Wait...",
                ShowCancelButton = false,
                ProgressBarStyle = ProgressBarStyle.MarqueeProgressBar
            };
            progressDialog.DoWork += (sender, e) => task().ConfigureAwait(configureAwait).GetAwaiter().GetResult();
            progressDialog.ShowDialog();
        }

Now when I try to run this update function through the progress dialog update.UpdateAvailable remains false.

var updater = new Updater("https://raw.githubusercontent.com/nlogozzo/NickvisionApp/main/NickvisionApp/UpdateConfig.json", Assembly.GetExecutingAssembly().GetName().Version);
           _progressDialogService.ShowDialog("Checking for update...", async () => await updater.CheckForUpdateAsync());
           if (updater.UpdateAvailable)
           {
              ...
           }
           else
           {
               await _contentDialogService.ShowAsync("No update is available at this time", "No Update Available", "OK");
           }

I also tried just passing updater.CheckForUpdateAsync as method pointer like so and still the same issue.
However, when I run await updater.CheckForUpdateAsync() on it's own line without the ProgressDialog, it works correctly.
Any ideas?

[nlogozzo]

I've come to the conclusion that the Win32 ProgressDialog implementation doesn't have good enough support for async command.
I implemented my own found here: https://github.com/nlogozzo/Nickvision.WPF/tree/main/Nickvision.WPF/Controls

[arsu-leo]

I've come to the conclusion that the Win32 ProgressDialog implementation doesn't have good enough support for async command. I implemented my own found here: https://github.com/nlogozzo/Nickvision.WPF/tree/main/Nickvision.WPF/Controls

I have no doubt there is some mess when you try to join async and Win32.
I just wanted you to take a look on this implementation in case it serves you as inspiration

https://stackoverflow.com/a/33411037/1382345

[virzak]

IMO, It is preferable to migrate away from BackgroundWorker in the library to achieve a user-friendly async method handling.

From official documentation:

The async-based approach to asynchronous programming is preferable to existing approaches in almost every case. In particular, this approach is better than the BackgroundWorker class for I/O-bound operations because the code is simpler and you don't have to guard against race conditions. In combination with the Task.Run method, async programming is better than BackgroundWorker for CPU-bound operations because async programming separates the coordination details of running your code from the work that Task.Run transfers to the thread pool.