Feature: allow to configure the InvocationContext/Console instance.

[tmds]

This is related to #2084.

The API would be on the CommandLineBuilder:

void UseInvocationContextFactory(Func<ParseResult, IConsole?, InvocationContext> factory);

Or mutable CommandLineConfiguration:

Func<ParseResult, IConsole?, InvocationContext> InvocationContextFactory { get; set; }

If the instance is IDisposable/IAsyncDisposable, it should be disposed at the end of the invocation.

Similarly, it would be interesting to have a way of controlling the default console:

void UseConsole(Func<ParseResult, IConsole> factory);
// or
Func<ParseResult, IConsole> ConsoleFactory { get; set; }

[tmds]

cc @jonsequitur @adamsitnik @KathleenDollard

[KalleOlaviNiemitalo]

To be useful, that would require unsealing InvocationContext.

[KalleOlaviNiemitalo]

Supporting IAsyncDisposable on .NET Standard 2.0 and .NET Framework would need a dependency on Microsoft.Bcl.AsyncInterfaces, unless you check for it using reflection and string comparisons.

[adamsitnik]

With #2106 we have removed IConsole and replaced it with two TextWriters added to config. We are also going to remove the InvocationContext very soon (#2108)

Those who need some extra input for command action have following possibilities:

1. Capture it in a closure:

static async Task Main(string[] args)
{
    Command testCommand = new("test", "Test command");

    DateTime customState = DateTime.UtcNow;
    testCommand.SetAction((parseResult, cancellationToken) => ClosureAsync(cancellationToken));

    await testCommand.Parse(args).InvokeAsync();

    Task ClosureAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine($"Custom state: {customState}");

        return Task.CompletedTask;
    }
}

2. Create a custom type that derives from Command, make it a state of the Command:

static async Task Main(string[] args)
{
    Command testCommand = new MyCommand();

    await testCommand.Parse(args).InvokeAsync();
}

class MyCommand : Command
{
    private DateTime customState = DateTime.UtcNow;

    public MyCommand() : base("test", "Test command")
    {
        SetAction((parseResult, cancellationToken) => NoClosure(cancellationToken));
    }

    Task NoClosure(CancellationToken cancellationToken)
    {
        Console.WriteLine($"Custom state: {customState}");

        return Task.CompletedTask;
    }
}

3. Create a custom type that derives from CliAction and owns given state:

static async Task Main(string[] args)
{
    Command testCommand = new("test", "Test command")
    {
        Action = new MyAction(ActionAsync)
    };

    await testCommand.Parse(args).InvokeAsync();

    Task<int> ActionAsync(DateTime customState, CancellationToken cancellationToken)
    {
        Console.WriteLine($"Custom state: {customState}");

        return Task.FromResult(0);
    }
}

class MyAction: CliAction
{
    private DateTime customState = DateTime.UtcNow;
    private readonly Func<ParseResult, DateTime, Task<int>> _action;

    public MyAction(Func<ParseResult, DateTime, Task<int>> action)
    {
        _action = action;
    }

    public override Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
        => _action.Invoke(parseResult, customState);

    public override int Invoke(ParseResult parseResult) => throw new NotSupportedException();
}