Using IProgress when reporting progress for async await code vs progress bar control

Question

private static async Task FuncAsync(DataTable dt, DataRow dr)
{
    try
    {
        await Task.Delay(3000); //assume this is an async http post request that takes 3 seconds to respond
        Thread.Sleep(1000) //assume this is some synchronous code that takes 2 second
    }
    catch (Exception e)
    {
        Thread.Sleep(1000); //assume this is synchronous code that takes 1 second
    }
}

private async void Button1_Click(object sender, EventArgs e)
{
    List<Task> lstTasks = new List<Task>();

    DataTable dt = (DataTable)gridview1.DataSource;

    foreach (DataRow dr in dt.Rows)
    {
        lstTasks.Add(FuncAsync(dr["colname"].ToString());                
    }            

    while (lstTasks.Any())
    {   
        Task finishedTask = await Task.WhenAny(lstTasks);
        lstTasks.Remove(finishedTask);
        await finishedTask;
        progressbar1.ReportProgress();
    }                        
}

Assuming the datatable has got 10000 rows.

In the code, on button click, at the 1st iteration of the for loop, an async api request is made. While it takes 3 seconds, the control immediately goes to the caller. So the for loop can make the next iteration, and so on.

When the api response arrives, the code below the await runs as a callback. Thus blocking the UI thread and any incomplete for loop iterations will be delayed until the callback completes irrespective of whether I use await WhenAny or WhenAll.

All code runs on the UI thread due to the presence of synchronization context. I can do ConfigureAwait false on Task.Delay so the callbacks run on separate threads in order to unblock the ui thread.

Say 1000 iterations are made when the 1st await returns and when the 1st iterations await call back runs the following iterations will have completed completed awaits so their callbacks will run. Effectively callbacks will run one after the other if configure await is true. If false then they will run in parallel on separate threads.

So I think that the progress bar that I am updating in the while loop is incorrect because - by the time the code reaches the while block, most of the initial for loop iterations will have been already completed. I hope that I have understood correctly so far.

I have the following options to report progress from inside the task:

1. using IProgress (I think this is more suitable to report progress from another thread [for example when using Task.Run], or in usual async await if the configure await is false, resulting in code below the await to run in separate thread otherwise it will not show the progress bar moving as the ui thread will be blocked running the callbacks. In my current example code always runs on the same UI thread). So I was thinking the below point may be more appropriate solution.

2. making the Task non-static so that I can access the progress bar from within the Task and do porgressbar1.PerformStep().

Another thing I have noticed is that await WhenAll doesn't guarantee that IProgress is fully executed.

Answer 1

The IProgress<T> implementation offered natively by the .NET platform, the Progress<T> class, has the interesting characteristic of notifying the captured SynchronizationContext asynchronously, by invoking its Post method. This characteristic sometimes results to unexpected behavior. For example can you guess what effect has the code below to the Label1 control?

IProgress<string> progress = new Progress<string>(s => Label1.Text = s);

progress.Report("Hello");

Label1.Text = "World";

What text will be eventually written to the label, "Hello" or "World"? The correct answer is: "Hello". The delegate s => Label1.Text = s is invoked asynchronously, so it runs after the execution of the Label1.Text = "World" line, which is invoked synchronously.

Implementing a synchronous version of the Progress<T> class is quite trivial. All you have to do is copy-paste Microsoft's source code, rename the class from Progress<T> to SynchronousProgress<T>, and change the line _synchronizationContext.Post(... to _synchronizationContext.Send(.... This way every time you invoke the progress.Report method, the call will block until the invocation of the delegate on the UI thread is completed. A simplified implementation can be found here. The unfortunate implication of this is that if the UI thread is blocked for some reason, for example because you used the .Wait() or the .Result to wait synchronously for the task to complete, your application will deadlock.

The asynchronous nature of the Progress<T> class is rarely a problem in practice, but if you want to avoid thinking about it you can just manipulate the ProgressBar1 control directly. After all you are not writing a library, you are just writing code in the event handler of a button to make some HTTP requests. My suggestion is to forget about the .ConfigureAwait(false) hackery, and just let the main workflow of your asynchronous event handler to stay on the UI thread from start to end. If you have synchronous blocking code that needs to be offloaded to a ThreadPool thread, use the Task.Run method to offload it. To create your tasks, instead of manually adding tasks to a List<Task>, use the handly LINQ Select operator to project each DataRow to a Task. Also add a reference to the System.Data.DataSetExtensions assembly, so that the DataTable.AsEnumerable extension method becomes available. Finally add a throttler (a SemaphoreSlim), so that your application makes efficient use of the available network bandwidth, and it doesn't overburden the target machine:

private async void Button1_Click(object sender, EventArgs e)
{
    Button1.Enabled = false;
    const int maximumConcurrency = 10;
    SemaphoreSlim throttler = new(maximumConcurrency, maximumConcurrency);

    DataTable dataTable = (DataTable)GridView1.DataSource;
    ProgressBar1.Minimum = 0;
    ProgressBar1.Maximum = dataTable.Rows.Count;
    ProgressBar1.Step = 1;
    ProgressBar1.Value = 0;

    Task[] tasks = dataTable.AsEnumerable().Select(async row =>
    {
        await throttler.WaitAsync();
        try
        {
            await Task.Delay(3000); // Simulate an asynchronous HTTP request
            await Task.Run(() => Thread.Sleep(2000)); // Simulate synchronous code
        }
        catch
        {
            await Task.Run(() => Thread.Sleep(1000)); // Simulate synchronous code
        }
        finally
        {
            throttler.Release();
        }
        ProgressBar1.PerformStep();
    }).ToArray();

    await Task.WhenAll(tasks);
    Button1.Enabled = true;
}

Answer 2

You can simply add a wrapper function:

private IProgress<double> _progress;
private int _jobsFinished = 0;
private int _totalJobs = 1000;

private static async Task FuncAsync()
{
    try
    {
        await Task.Delay(3000); //assume this is an async http post request that takes 3 seconds to respond

        Thread.Sleep(1000); //assume this is some synchronous code that takes 2 second
    }
    catch (Exception e)
    {
        Thread.Sleep(1000); //assume this is synchronous code that takes 1 second
    }
}

private async Task AwaitAndUpdateProgress()
{
    await FuncAsync(); // Can also do Task.Run(FuncAsync) to run on a worker thread
    _jobsFinished++;
    _progress.Report((double) _jobsFinished / _totalJobs);
}

And then just WhenAll after adding all the calls.