/// <summary>
/// Runs an instance of <see cref="CommandLineApplication" /> to provide
/// command line parsing on the given <paramref name="args" />. This method should be the primary approach
/// taken for command line applications which use the Builder API for configuration.
/// </summary>
/// <param name="hostBuilder">This instance</param>
/// <param name="args">The command line arguments</param>
/// <param name="cancellationToken">A cancellation token</param>
/// <returns>A task whose result is the exit code of the application</returns>
public static async Task <int> RunCommandLineApplicationAsync(
this IHostBuilder hostBuilder, string[] args, CancellationToken cancellationToken = default)
{
var exceptionHandler = new StoreExceptionHandler();
var state = new CommandLineState(args);
hostBuilder.ConfigureServices(
(context, services)
=>
{
services
.TryAddSingleton <IUnhandledExceptionHandler>(exceptionHandler);
services
.AddSingleton <IHostLifetime, CommandLineLifetime>()
.TryAddSingleton(PhysicalConsole.Singleton);
services
.AddSingleton(provider =>
{
state.SetConsole(provider.GetService <IConsole>());
return(state);
})
.AddSingleton <CommandLineContext>(state)
.AddSingleton <ICommandLineService, CommandLineService>();
});
using var host = hostBuilder.Build();
await host.RunAsync(cancellationToken);
if (exceptionHandler.StoredException != null)
{
ExceptionDispatchInfo.Capture(exceptionHandler.StoredException).Throw();
}
return(state.ExitCode);
}
/// <summary>
/// Configures an instance of <see cref="IHostBuilder"/> for running a <see cref="CommandLineApplication"/>.
/// </summary>
/// <typeparam name="TApp"></typeparam>
/// <param name="hostBuilder"></param>
/// <param name="args"></param>
/// <param name="applicationState"></param>
/// <returns></returns>
public static IHostBuilder ConfigureCommandLineApplication <TApp>(
this IHostBuilder hostBuilder,
string[] args,
out CommandLineState applicationState)
where TApp : class
{
var state = new CommandLineState(args);
hostBuilder.ConfigureServices((_, services) =>
{
services.AddSingleton(PhysicalConsole.Singleton);
services.TryAddSingleton(provider =>
{
state.SetConsole(provider.GetRequiredService <IConsole>());
return(state);
});
services
.AddSingleton <IHostLifetime, CommandLineLifetime>()
.AddSingleton <CommandLineContext>(state)
.AddSingleton <ICommandLineService, CommandLineService <TApp> >();
});
applicationState = state;
return(hostBuilder);
}
/// <summary>
/// Runs an instance of <typeparamref name="TApp" /> using <see cref="CommandLineApplication" /> to provide
/// command line parsing on the given <paramref name="args" />. This method should be the primary approach
/// taken for command line applications.
/// </summary>
/// <typeparam name="TApp">The type of the command line application implementation.</typeparam>
/// <param name="hostBuilder">This instance.</param>
/// <param name="args">The command line arguments.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task whose result is the exit code of the application.</returns>
public static async Task <int> RunCommandLineAsync <TApp>(
this IHostBuilder hostBuilder,
string[] args,
CancellationToken cancellationToken = default) where TApp : class
{
var exceptionHandler = new StoreExceptionHandler();
var state = new CommandLineState(args);
hostBuilder.ConfigureServices(
(context, services)
=>
{
services
.TryAddSingleton <IUnhandledExceptionHandler>(exceptionHandler);
services
.AddSingleton <IHostLifetime, CommandLineLifetime>()
.TryAddSingleton(PhysicalConsole.Singleton);
services
.AddSingleton(provider =>
{
state.SetConsole(provider.GetService <IConsole>());
return(state);
})
.AddSingleton <CommandLineContext>(state)
.AddSingleton <ICommandLineService, CommandLineService <TApp> >();
});
hostBuilder.UseSerilog((context, logger) =>
{
var configuration = context.Configuration;
logger.ReadFrom.Configuration(configuration)
.Enrich.FromLogContext()
.WriteTo.Console();
});
using var host = hostBuilder.Build();
await host.RunAsync(cancellationToken);
if (exceptionHandler.StoredException != null)
{
ExceptionDispatchInfo.Capture(exceptionHandler.StoredException).Throw();
}
return(state.ExitCode);
}
/// <summary>
/// Configures an instance of <typeparamref name="TApp" /> using <see cref="CommandLineApplication" /> to provide
/// command line parsing on the given <paramref name="args" />.
/// </summary>
/// <typeparam name="TApp">The type of the command line application implementation</typeparam>
/// <param name="hostBuilder">This instance</param>
/// <param name="args">The command line arguments</param>
/// <param name="configure">The delegate to configure the application</param>
/// <returns><see cref="IHostBuilder"/></returns>
public static IHostBuilder UseCommandLineApplication <TApp>(
this IHostBuilder hostBuilder,
string[] args,
Action <CommandLineApplication <TApp> > configure)
where TApp : class
{
configure ??= _ => { };
var state = new CommandLineState(args);
hostBuilder.Properties[typeof(CommandLineState)] = state;
hostBuilder.ConfigureServices((context, services) =>
services
.AddCommonServices(state)
.AddSingleton <ICommandLineService, CommandLineService <TApp> >()
.AddSingleton(configure));
return(hostBuilder);
}
/// <summary>
/// Runs an instance of <see cref="CommandLineApplication" /> using builder API to provide
/// command line parsing on the given <paramref name="args" />.
/// </summary>
/// <param name="hostBuilder">This instance</param>
/// <param name="args">The command line arguments</param>
/// <param name="configure">The delegate to configure the application</param>
/// <param name="cancellationToken">A cancellation token</param>
/// <returns>A task whose result is the exit code of the application</returns>
#pragma warning disable RS0026 // disable warning about optional parameter for CancellationToken
public static async Task <int> RunCommandLineApplicationAsync(
#pragma warning restore RS0026
this IHostBuilder hostBuilder,
string[] args,
Action <CommandLineApplication> configure,
CancellationToken cancellationToken = default)
{
configure ??= _ => { };
var state = new CommandLineState(args);
hostBuilder.Properties[typeof(CommandLineState)] = state;
hostBuilder.ConfigureServices((context, services) =>
services
.AddCommonServices(state)
.AddSingleton <ICommandLineService, CommandLineService>()
.AddSingleton(configure));
using var host = hostBuilder.Build();
return(await host.RunCommandLineApplicationAsync(cancellationToken));
}
/// <summary>
/// Runs an instance of <typeparamref name="TApp" /> using <see cref="CommandLineApplication" /> to provide
/// command line parsing on the given <paramref name="args" />. This method should be the primary approach
/// taken for command line applications.
/// </summary>
/// <typeparam name="TApp">The type of the command line application implementation</typeparam>
/// <param name="hostBuilder">This instance</param>
/// <param name="args">The command line arguments</param>
/// <param name="cancellationToken">A cancellation token</param>
/// <returns>A task whose result is the exit code of the application</returns>
public static async Task <int> RunCommandLineApplicationAsync <TApp>(
this IHostBuilder hostBuilder, string[] args, CancellationToken cancellationToken = default)
where TApp : class
{
var state = new CommandLineState(args);
hostBuilder.ConfigureServices(
(context, services)
=> services
.AddSingleton <IHostLifetime, CommandLineLifetime>()
.AddSingleton(state)
.AddSingleton <CommandLineContext>(state)
.AddSingleton(PhysicalConsole.Singleton)
.AddSingleton <ICommandLineService, CommandLineService <TApp> >());
using (var host = hostBuilder.Build())
{
await host.RunAsync(cancellationToken);
return(state.ExitCode);
}
}
public CommandLineApplication(params string[] args)
{
_console = new StringOutputConsole();
FakeHttpClientHandler = A.Fake <ServersListApiClientHandler>(o => o.CallsBaseMethods());
_host = new HostBuilder()
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureContainer <ContainerBuilder>(HostConfiguration.Container)
.ConfigureServices(HostConfiguration.Services)
.ConfigureLogging(HostConfiguration.Logging)
.ConfigureCommandLineApplication <RootCommandHandler>(args, out var state)
.ConfigureContainer <ContainerBuilder>(containerBuilder =>
{
containerBuilder.RegisterInstance(_console);
containerBuilder.RegisterInstance <HttpClientHandler>(FakeHttpClientHandler);
containerBuilder.RegisterInstance(new ServersListRenderer(false));
})
.Build();
_state = state;
_databaseContext = _host.Services.GetRequiredService <ServersDbContext>();
}
private static IServiceCollection AddCommonServices(this IServiceCollection services, CommandLineState state)
{
services.TryAddSingleton <StoreExceptionHandler>();
services.TryAddSingleton <IUnhandledExceptionHandler>(provider => provider.GetRequiredService <StoreExceptionHandler>());
services.TryAddSingleton(PhysicalConsole.Singleton);
services
.AddSingleton <IHostLifetime, CommandLineLifetime>()
.AddSingleton(provider =>
{
state.SetConsole(provider.GetRequiredService <IConsole>());
return(state);
})
.AddSingleton <CommandLineContext>(state);
return(services);
}
