Design advice for global initialization and cleanup

[rcdailey]

I have some tasks that I like to perform each time my CLI application is run:

• On start, ensure certain directories are created
• On shutdown, rotate and clean up log files

In the future, there may be more of these setup/teardown tasks. But that's it for now.

Note also that this logic requires dependency injection. Each piece of logic is its own object for testing purposes. Constructors require certain dependencies. However, in Program I do not get access to my container because that is hidden inside of CommandApp.Run(). So I am not able to resolve types in the Program class. I'm using Autofac, which separates its "builder" from its "container"; so I cannot resolve types until ITypeRegistrar.Build() is called, which again is inside Run() which is too late.

The only work around here is to create a base class for every AsyncCommand<T>, which is really tedious as it requires the base type to have a constructor to inject types used to perform the setup and teardown, in addition to requiring me to use a separate async virtual method to perform the actual processing so I have a chance to perform cleanup before ExecuteAsync() returns. Example:

public abstract class BaseCommand<T> : AsyncCommand<T>
    where T : CommandSettings
{
    private readonly IBaseCommandSetupTask[] _tasks;

    protected BaseCommand(IOrderedEnumerable<IBaseCommandSetupTask> tasks)
    {
        _tasks = tasks.ToArray();
    }

    public override async Task<int> ExecuteAsync(CommandContext context, T settings)
    {
        _tasks.ForEach(x => x.OnStart());

        try
        {
            await Process(settings);
        }
        finally
        {
            _tasks.Reverse().ForEach(x => x.OnFinish());
        }

        return 0;
    }

    public abstract Task Process(T settings);
}

Again I don't like this solution because of its complexity and boilerplate. I do not want to have to redundantly require upstream construction parameters in my derived classes. It's much easier and cleaner if I can do this stuff outside of command classes.

Do you have a workaround for this other than what I'm doing?

I think the long term solution here is to break up CommandApp.Run() into two methods. One to "parse" the commands, the other to actually execute/run them. The "parse" step would also invoke ITypeRegistrar.Build() and make the resolver available as a property. Example:

// Inside Program.cs
var app = new CommandApp();
// setup commands

app.Parse();

var init = app.TypeResolver.Resolve<AppInitializer>();
init.Setup();

int result = -1;

try
{
    result = app.Run(args);
}
finally
{
    init.Teardown();
}

return result;

It's not pretty, but hopefully you get the gist of it...

[rcdailey]

After looking at the code, I'm convinced there's no good answer right now. I believe some code changes are necessary to get an ideal solution. As such, I've created an issue here to cover any potential changes needed: #1093