What is the best way to use Progress?

[reneduesmann]

Hey guys,

i'm writing a downloader and i want to show the download progress of the files.

I have a list of "DownloadItem", after collecting this items, a method creates tasks. store the tasks in a list and after that, i wait of all tasks with await Task.WhenAll(tasks);.

In the task, i download the file with a HttpClient and use the Progress class, to notify a method of the current status of the download.
Also i have a static method, that will be called every time, when the progress is changed.

But i dont know, how i should use the AnsiConsole.Progress() call.

[patriksvensson]

@reneduesmann Below is some code that will download some files using HttpClient and await Task.WhenAll and shows progress.
The example uses C# 9, top-level programs, and Spectre.Console version 0.33.1-preview.0.1.

Hope it helps!

using Spectre.Console;
using System;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
var items = new (string name, string url)[]
{
    ("Ubuntu 20.04", "https://releases.ubuntu.com/20.04.1/ubuntu-20.04.1-desktop-amd64.iso"),
    ("Spotify", "https://download.scdn.co/SpotifySetup.exe"),
    ("Windows Terminal", "https://github.com/microsoft/terminal/releases/download/v1.5.3242.0/Microsoft.WindowsTerminalPreview_1.5.3242.0_8wekyb3d8bbwe.msixbundle"),
};

// Progress
await AnsiConsole.Progress()
    .Columns(new ProgressColumn[]
    {
        new TaskDescriptionColumn(),
        new ProgressBarColumn(),
        new PercentageColumn(),
        new RemainingTimeColumn(),
        new SpinnerColumn(),
    })
    .StartAsync(async ctx =>
    {
        await Task.WhenAll(items.Select(async item =>
        {
            var task = ctx.AddTask(item.name, new ProgressTaskSettings
            {
                AutoStart = false
            });

            await Download(client, task, item.url);
        }));
    });

// This methods downloads a file and updates progress
async Task Download(HttpClient client, ProgressTask task, string url)
{
    try
    {
        using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
        {
            response.EnsureSuccessStatusCode();

            // Set the max value of the progress task to the number of bytes
            task.MaxValue(response.Content.Headers.ContentLength ?? 0);
            // Start the progress task
            task.StartTask();

            var filename = url.Substring(url.LastIndexOf('/') + 1);
            AnsiConsole.MarkupLine($"Starting download of [u]{filename}[/] ({task.MaxValue} bytes)");

            using (var contentStream = await response.Content.ReadAsStreamAsync())
            using (var fileStream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None, 8192, true))
            {
                var buffer = new byte[8192];
                while (true)
                {
                    var read = await contentStream.ReadAsync(buffer, 0, buffer.Length);
                    if (read == 0)
                    {
                        AnsiConsole.MarkupLine($"Download of [u]{filename}[/] [green]completed![/]");
                        break;
                    }

                    // Increment the number of read bytes for the progress task
                    task.Increment(read);

                    // Write the read bytes to the output stream
                    await fileStream.WriteAsync(buffer, 0, read);
                }
            }
        }
    }
    catch (Exception ex)
    {
        // An error occured
        AnsiConsole.MarkupLine($"[red]Error:[/] {ex}");
    }
}

[reneduesmann]

Hey @patriksvensson,
thanks for your solution.
It's working and i changed my program.

But do you have a idea, how to use it with Progress?

[patriksvensson]

@reneduesmann Ah, sorry, didn't realize you were talking about System.Progress. I haven't used that before, but show me the code you want to get working with it and I'll try to help out.

[reneduesmann]

Here is my code with System.Progress @patriksvensson
I have a custom Interface for the Progress, but that is not needed here.
Also i have an extension for HttpClient with the Parameter IProgress<CustomInterface> progress and report to them.

while((bytesRead = await sourceStream.ReadAsync(buffer.AsMemory(0, buffer.Length), cancellationToken)) != 0)
            {
                await destinationStream.WriteAsync(buffer.AsMemory(0, bytesRead), cancellationToken);

                totalBytesRead += bytesRead;
                long singleTicks = Math.Max(1, singleTime.ElapsedTicks);

                singleTime.Restart();

                progress?.Report(new TransferProgress(totalTime.Elapsed, bytesRead * TimeSpan.TicksPerSecond / singleTicks, 
                    totalBytesRead, expectedTotalBytes));

                if(cancellationToken.IsCancellationRequested)
                {
                    break;
                }
            }

I create a new instace of the Progress like

IProgress<ITransferProgress> progress = new Progress<ITransferProgress>(x =>
            {
                
            });

And give it the above code.
Also i have an action in the progress, that will be triggered every time, when reading from sourceStream.
I had a static method to log the progress. The anonym variable x contains the information of the progress.

The workflow is, i collect all items, that will be downloaded and call a method that have this code

while (this._DownloadItems.TryDequeue(out DownloadItem downloadItem) || downloadedItems < this._DownloadItems.Count)
                    {
                        if (downloadItem != null)
                        {
                            await this._SemaphoreSlim.WaitAsync();

                            Task task = Task.Run(async () =>
                            {
                                try
                                {
                                    if (downloadItem.BeforeDownloadStartAction is not null)
                                    {
                                        await downloadItem.BeforeDownloadStartAction();
                                    }

                                    string filename = downloadItem.OutputPath.Split("\\")[^1].ReplaceSpectreConsoleCharacters();

                                    bool completed = await downloadItem.DownloadAsync();

                                    if (completed)
                                    {
                                        Interlocked.Increment(ref downloadedItems);

                                        if (downloadItem.SuccessfullDownloadAction is not null)
                                        {
                                            await downloadItem.SuccessfullDownloadAction();
                                        }
                                    }
                                    else
                                    {
                                        if (downloadItem.FailedDownloadAction is not null)
                                        {
                                            await downloadItem.FailedDownloadAction();
                                        }

                                        this._DownloadItems.Enqueue(downloadItem);
                                    }
                                }
                                finally
                                {
                                    this._SemaphoreSlim.Release();
                                }
                            });

                            tasks.Add(task);
                        }
                    }

                    await Task.WhenAll(tasks);

But i dont know, how to implement the Spectre Progress to that.

[patriksvensson]

@reneduesmann You would need to keep a reference to the ProgressTask you created in your Progress<T> callback and call Increment on it.

[brickscrap]

@reneduesmann You would need to keep a reference to the ProgressTask you created in your Progress<T> callback and call Increment on it.

Forgive me if this seems like a silly question, but how exactly would you get that reference? Doesn't the solution you provide mean that the functionality needs to know about the interface? Isn't that usually a bad idea?

[nenadvicentic]

I've made example of console app using System.Progress and helper class AnsiConsoleProgress which contains progress-callback method ReportProgress and holds references of two ProgressTask instances.

// See https://aka.ms/new-console-template for more information
using Spectre.Console;
class Program
{
    class ProgressInfo
    {
        public double Task1Increase { get; set; }
        public double Task2Increase { get; set; }
    }

    class AnsiConsoleProgress
    {
        private readonly ProgressTask _task1;
        private readonly ProgressTask _task2;

        private readonly object _consoleLock = new object();

        public AnsiConsoleProgress(ProgressTask task1, ProgressTask task2)
        {
            _task1 = task1;
            _task2 = task2;
        }

        public void ReportProgress(ProgressInfo info)
        {
            lock (_consoleLock)
            {
                _task1.Increment(info.Task1Increase);
                _task2.Increment(info.Task2Increase);
            }
        }
    }

    public static async Task Main(string[] args)
    {
        AnsiConsole.WriteLine("Start");
        await AnsiConsole.Progress()
            .StartAsync(async ctx =>
            {
                // Define tasks
                var task1 = ctx.AddTask("[green]Reticulating splines[/]");
                var task2 = ctx.AddTask("[green]Folding space[/]");

                var ansiProgress = new AnsiConsoleProgress(task1, task2);
                var progress = new Progress<ProgressInfo>(ansiProgress.ReportProgress);

                await DoAsync(progress);
            });
        AnsiConsole.WriteLine("Finish");
    }

    private static async Task DoAsync(IProgress<ProgressInfo> progress)
    {
        int counter = 0;

        while(counter < 200)
        { 
            await Task.Delay(100);
            counter++;
            progress.Report(new ProgressInfo { Task1Increase = 1.5, Task2Increase = 0.5 });
        }
    }
}