public async Task AsyncProgressPolling()
{
    cts = new CancellationTokenSource();
    var progress = new EventProgress<GetAllPingsPartialResult>();

try
    {
        progress.ProgressChanged += (source, e) =>
        {
            ProgressBar.Value = e.Value.Count % 100;
        };
foreach (var item in await GetAllPingsAsync(cts.Token, progress))
        {
            Console.WriteLine(item);
        }
    }
catch (OperationCanceledException)
    {
        Console.WriteLine("Operation canceled.");
    }
}

 

The new code creates an EventProgress<T> object. This object supports a ProgressChanged event that enables the worker tasks to report progress as their tasks progress. When the event is raised, the progress bar moves ahead.

 

The other side of this convention is to write the code that runs the background operation in such a way that it raises those events as it progresses. Here’s the code that runs the background tasks, and raises that progress event:

 

        public async Task<string[]> GetAllPingsAsync(
    CancellationToken cancel, IProgress<GetAllPingsPartialResult> progress)
{
    var sites = new List<string>();
for (int i = 0; i < 30; i++)
    {
        sites.Add("http://www.microsoft.com");
        sites.Add("http://msdn.microsoft.com");
        sites.Add("http://www.xbox.com");
    }
    var results = new List<string>(sites.Count);
foreach (var site in sites)
    {
        cancel.ThrowIfCancellationRequested();
        var time = DateTime.UtcNow;
try {await new WebClient().DownloadStringTaskAsync(site);}
catch {}
        var ms = (DateTime.UtcNow - time).TotalMilliseconds;
        results.Add(String.Format("[{0}] {1}", ms, site));
if (progress != null) 
            progress.Report(new GetAllPingsPartialResult() 
                { 
                     Pings = new ReadOnlyCollection<string>(results), 
                     Count = results.Count 
                });
    }
return results.ToArray();
}

This method contains the familiar event source pattern.

As this method does its work, it raises the Progress event by calling progress.Report(), passing it the current results, and the count of the results.

 

Methods designed to be run asynchronously should consider supporting progress reporting. There’s a standard way to do it, and you only report progress to those callers that ask for it.

Client code can ask for progress using the same mechanism.