public class Program
{
    private static readonly CancellationTokenSource TokenSource;

    static Program()
    {
        TokenSource = new CancellationTokenSource();
        Console.CancelKeyPress += (sender, eventArgs) =>
        {
            TokenSource.Cancel();
            eventArgs.Cancel = true;
        };
    }

    public static void Main(string[] args) =>
        MainAsync(args, TokenSource.Token).ConfigureAwait(false).GetAwaiter().GetResult();

    private static async Task MainAsync(string[] args, CancellationToken ct)
    {
        var loggerFactory = new LoggerFactory()
            .AddConsole(LogLevel.Trace, true);

        var logger = loggerFactory.CreateLogger<Program>();

        logger.LogInformation("Application started");
        try
        {
            using (var hostBuilder = new HostBuilder("ASPNETCORE_ENVIRONMENT")
                .UseLoggerFactory(loggerFactory)
                .UseStartup<Startup>()
                .ConfigureConfigurationBuilder(p => p.Builder.AddCommandLine(args)))
            {
                await hostBuilder.RunHostAsync<Host>(ct);
            }
        }
        catch (TaskCanceledException)
        {
            logger.LogWarning("Application was terminated by user request");
        }
        catch (Exception e)
        {
            logger.LogCritical(0, e, "Unexpected exception");
        }
        finally
        {
            logger.LogInformation("Application terminated. Press <enter> to exit...");
            Console.ReadLine();
        }
    }

    private class Startup : HostStartup
    {
        public override void ConfigureConfigurationBuilder(IConfigurationBuilderParam param)
        {
            param.Builder
                .SetBasePath(param.Environment.ContentRootPath)
                .AddJsonFile("appsettings.json", true, true)
                .AddJsonFile($"appsettings.{param.Environment.Name}.json", true, true)
                .AddEnvironmentVariables();
        }

        public override IServiceProvider BuildServiceProvider(IServiceProviderBuilderParam param)
        {
            var container = new Autofac.ContainerBuilder();
            container.Populate(param.ServiceCollection);
            return new AutofacServiceProvider(container.Build());
        }
    }

    private class Host : IHost
    {
        private readonly IHostingEnvironment _env;
        private readonly IConfigurationRoot _configurationRoot;
        private readonly ILogger<Host> _logger;

        public Host(IHostingEnvironment env, IConfigurationRoot configurationRoot, ILogger<Host> logger)
        {
            _env = env;
            _configurationRoot = configurationRoot;
            _logger = logger;
        }

        public Task RunAsync(CancellationToken ct)
        {
            _logger.LogDebug("Running host...");

            return Task.CompletedTask;
        }
    }
}