using System;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using Microsoft.Extensions.Hosting;

using Microsoft.Extensions.Logging;

using Microsoft.Extensions.DependencyInjection;

using System.Diagnostics;

using Serilog;

using Serilog.Sinks.SystemConsole.Themes;

​

public class Program

{

    static async Task Main(string[] args)

    {

        Log.Logger = new LoggerConfiguration()

            .Enrich.FromLogContext()

            .WriteTo.Console(theme: ConsoleTheme.None)

            .CreateLogger();

            //.CreateBootstrapLogger();

        var firstLogger = Log.Logger;

​

        var builder = new HostBuilder()

            .ConfigureServices(services =>

            {

                services.AddHostedService<SampleHostedService>();

                //services.AddSerilog();

                //services.AddSerilog((_,_) => {});

                Console.WriteLine($"ConfigureServices() {firstLogger == Log.Logger}");

            })

            .ConfigureLogging(logging => 

            {

                //logging.AddSerilog();

                Console.WriteLine($"ConfigureLogging() {firstLogger == Log.Logger}");

            })

            //.UseSerilog()

            //.UseSerilog((_,_) => {})

            ;

        var app = builder.Build();

        Console.WriteLine($"Build() {firstLogger == Log.Logger}");

        var loggerProviders = app.Services.GetServices<ILoggerProvider>();

        Console.WriteLine($"loggerProviders: {loggerProviders.Count()}");

        var loggerFactories = app.Services.GetServices<ILoggerFactory>();

        Console.WriteLine($"loggerFactories: {loggerFactories.Count()}");

        firstLogger.Information("First logger still works!");

        Log.Logger.Information("Current logger also works!");

        await app.RunAsync();

    }

}

​

public class SampleHostedService : BackgroundService

{

    readonly ILogger<SampleHostedService> _logger;

    readonly IHostApplicationLifetime _hostApplicationLifetime;

    public SampleHostedService(ILogger<SampleHostedService> logger, IHostApplicationLifetime hostApplicationLifetime)

    {

        _hostApplicationLifetime = hostApplicationLifetime;

        _logger = logger;

    }

​

    public override async Task StartAsync(CancellationToken cancellationToken)

    {

        _logger.LogInformation("SampleHostedService started at: {time}", DateTimeOffset.Now);

        new Timer((o) => _hostApplicationLifetime.StopApplication(), null, TimeSpan.Zero, TimeSpan.FromSeconds(5));

        await base.StartAsync(cancellationToken);

    }

​

    public override async Task StopAsync(CancellationToken cancellationToken)

    {

        var stopWatch = Stopwatch.StartNew();

        _logger.LogInformation("SampleHostedService stopped at: {time}", DateTimeOffset.Now);

        await base.StopAsync(cancellationToken);

        _logger.LogInformation("SampleHostedService took {ms} ms to stop.", stopWatch.ElapsedMilliseconds);

    }

​

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)

    {

        while (!stoppingToken.IsCancellationRequested)

        {

            _logger.LogInformation("SampleHostedService running at: {time}", DateTimeOffset.Now);

            await Task.Delay(TimeSpan.FromSeconds(120));

        }

    }

}