Alternative status API

[buybackoff]

Current status API with closures and context is very inconvenient, it hides variables inside closure scope and makes it very hard to annotate existing code with processing steps.

This helper took me 5 minutes without AI for a working POC and then some time to get the exact behavior I need:

internal class StatusHelper : IDisposable
{
    private Status? _status;
    private StatusContext? _ctx;

    private readonly Queue<(string? Status, string? PreviousStepDone, DateTime Started)> _queue = new();

    private string? _previousStepDone;
    private DateTime _previousStepStart;
    private DateTime _start;

    private string? _done;
    private Task? _task;

    public void Status(string value, string? stepDone = null)
    {
        if (_task is null)
        {
            _start = DateTime.UtcNow;
            _status = AnsiConsole.Status();
            _task = _status.StartAsync(value, async context =>
            {
                _ctx = context;

                while (_ctx is { } ctx)
                {
                    await Task.Delay(1);

                    if (_queue.Count == 0)
                        continue;

                    (string? status, string? stepDone, DateTime started) x = default;
                    while (_queue.TryDequeue(out x))
                    {
                        var status = x.status;
                        stepDone = x.stepDone;
                        var seconds = (DateTime.UtcNow - x.started).TotalSeconds;

                        if (!string.IsNullOrWhiteSpace(status) && ctx.Status != status)
                        {
                            ctx.Status = status;
                            ctx.Refresh();

                            if (!string.IsNullOrWhiteSpace(stepDone))
                                AnsiConsole.MarkupLine($"[gray]✓ {Markup.Escape(stepDone)} [i]({seconds:N1}s)[/][/]");
                        }
                    }
                }

                if (_done is { } done)
                    AnsiConsole.MarkupLine($"[green]✓ {Markup.Escape(done)} [i]({(DateTime.UtcNow - _start).TotalSeconds:N1}s)[/][/]");
            });

            _queue.Enqueue((value, stepDone, DateTime.UtcNow));
        }
        else
        {
            _queue.Enqueue((value, _previousStepDone, _previousStepStart));
        }

        _previousStepDone = stepDone;
        _previousStepStart = DateTime.UtcNow;
    }

    public void Done(string done) => _done = done;

    public void Dispose()
    {
        _ctx = null;
        _task?.Wait();
    }
}

The usage is:

using var status = new StatusHelper();
status.Status("Step 1...", "Step1 is done");
var scope1 = ....
...
status.Status("Step 2...", "Step2 is done");
var scope2 = f(scope1)
...
status.Done("Done processing") // optional
var sone = f(scope1, scope2)

It's not perfect and will leak if not disposed, but so much better than the existing API as it has zero impact on the existing code. It would be much appreciated to have something like this built-in.