I have a Windows worker service in ASP.NET Core 8. It has two threads:

1. The one that processes today’s transactions
2. The one that processes previous days

Then the one that processes today’s transaction is further group.

They all fetch data from the same database. However, I observed that the service process is very slow.

Kindly assist to improve and make it faster

Main code:

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;
    private readonly ITransactionProcessingService _transactionProcessingService;
    private readonly IConfiguration _configuration;
    private System.Timers.Timer _awaitingTimer;

    public Worker(ILogger<Worker> logger, 
        ITransactionProcessingService transactionProcessingService,
        IConfiguration configuration)
    {
        _logger = logger;
        _transactionProcessingService = transactionProcessingService;
        _configuration = configuration;
        InitializeTimers();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("School App Processor running at: {time}", DateTimeOffset.Now);

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                _logger.LogInformation("Daily Transaction running at: {time}", DateTimeOffset.Now);
                var todayTask = Task.Run(() => _transactionProcessingService.ProcessDailyTransactionsAsync(), stoppingToken);
                await Task.WhenAll(todayTask);
            }
            catch (Exception ex)
            {
                _logger.LogError($"Error in School App Processor execution: {ex.Message}");
            }

            await Task.Delay(TimeSpan.FromSeconds(20), stoppingToken); 
        }
    }

    private void InitializeTimers()
    {
        _awaitingTimer = new System.Timers.Timer(TimeSpan.FromMinutes(2));
        _awaitingTimer.Enabled = true;
        _awaitingTimer.AutoReset = false;
        _awaitingTimer.Elapsed += _awaitingTimer_Elapsed;
    }

    private void _awaitingTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        try
        {
            _logger.LogInformation("Processing previous transactions...");
            Task.Run(() => _transactionProcessingService.ProcessPreviousTransactionsAsync()).Wait();
            _logger.LogInformation("Completed processing previous transactions.");
        }
        catch (Exception ex)
        {
            _logger.LogError($"Error in processing previous transactions: {ex.Message}");
        }
        finally
        {
            _awaitingTimer.Start();
        }
    }

    public override Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Previous transactions service starting...");
      _awaitingTimer?.Start();
        return base.StartAsync(cancellationToken);
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Previous transactions service stopping...");

        if (_awaitingTimer != null)
        {
            _awaitingTimer?.Stop();
            _awaitingTimer = null;
        }

        await base.StopAsync(cancellationToken);

        _logger.LogInformation("Worker service stopped.");
    }
}