public class Program
    {
        public static void Main(string[] args)
        {
            Log.Logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Warning)
                .Enrich.FromLogContext()
                .WriteTo.File(@"C:\SosaBot\LogFile.txt")
                .CreateLogger();

            try
            {
                Log.Information("Starting up the Service");
                CreateHostBuilder(args).Build().Run();
                return;
            }
            catch (Exception ex)
            {
                Log.Fatal(ex, "-ther was a problem, starting the service");
                return;
            }
            finally
            {
                Log.CloseAndFlush();
            }
        }

        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            return Host.CreateDefaultBuilder(args)
                .UseWindowsService()
                .ConfigureServices((hostContext, services) =>
                {
                services.AddHostedService<Worker>();
                })
                .UseSerilog();
        }
    }

public class Worker : BackgroundService
    {
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                await Bot.Run();
                await Task.Delay(1000 * 60 * 3, stoppingToken);
            }
        }
    }

public static class Bot
    {
        public static async Task Run()
        {
            Log.Information("Starting Bot");

            var userClient = new TwitterClient(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET);

            (await userClient.Search.SearchTweetsAsync("Sportsfreund Sosa"))
                .ToList()
                .ForEach(async tweet =>
                {
                    Log.Information($"retweeting: {tweet.FullText}");
                    await userClient.Tweets.PublishRetweetAsync(tweet.Id);
                });

            Log.Information("Stopping Bot");
        }
    }

        public static int Main(string[] args)
            => RunHostBuilder<Startup>(args);

        public static int RunHostBuilder<TStartup>(string[] args) where TStartup : class
        {
            try
            {
                using IHost host = CreateHostBuilder<TStartup>(args).Build();
                host.Run();

                return 0;
            }
            catch (Exception ex)
            {
                // Log.Logger will likely be internal type "Serilog.Core.Pipeline.SilentLogger"
                // This will log into Console, when app fails on startup
                if (Log.Logger == null || Log.Logger.GetType().Name == "SilentLogger")
                {
                    Log.Logger = new LoggerConfiguration()
                        .MinimumLevel.Debug()
                        .WriteTo.Console()
                        .CreateLogger();
                }

                Log.Fatal(ex, "Host terminated unexpectedly");

                return 1; /* 0 = ok, 1 = general error */
            }
            finally
            {
                Log.CloseAndFlush();
            }
        }

        public static IHostBuilder CreateHostBuilder<TStartup>(string[] args)
            where TStartup : class
            => Host.CreateDefaultBuilder(args)
                .UseSerilog()
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<TStartup>()
                        .CaptureStartupErrors(true);
                });

                .UseSerilog((hostingContext, loggerConfiguration) =>
                {
                    loggerConfiguration.ReadFrom.Configuration(hostingContext.Configuration);
                })

public static async Task Run()
        {
            var userClient = new TwitterClient(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET);

            var tweets = (await userClient.Search.SearchTweetsAsync("Sportsfreund Sosa"))
                 .OrderByDescending(tweet => tweet.CreatedAt)
                 .ToList();

            foreach (var tweet in tweets)
            {
                try
                {
                    await userClient.Tweets.PublishRetweetAsync(tweet.Id);
                    Log.Information($"Retweeted: {{ {tweet.FullText} }}");
                }
                catch (TwitterException)
                {
                    return;
                }
            }
        }

private readonly ILogger<MqttSubcriptionWorker> logger;

public MqttSubcriptionWorker(ILogger<MqttSubcriptionWorker> logger)
{
    this.logger = logger;
}