Implementing service worker in existing ASP.NET Core MVC application

Question

I'm developing an ASP.NET Core MVC web application where I have these two tasks that should be running as background services:

1. Set the user status as "Expired" if EndOfSubscription date is == DateTime.Now
2. Before 1 month of EndOfSubscription date send a reminder e-mail to this user

After searching, I found that I can use service worker to implement this. But I'm totally confused how to use this service worker in existing ASP.NET Core MVC web application where I need to access my models and database.

Should I isolate these tasks in a separate service worker project? But in this case should I share the same database for both projects?

Can someone guide me with main steps in this kind of situations?

Thank you in advance.

Answer 1

Service worker or Worker service?

• A Service Worker is a way to run background tasks in a browser and definitely unsuitable if you want to execute something on the server.
• A Worker service is essentially a template with the (few) calls needed to run a BackgroundService/IHostedService in a console application and (optionally, through extensions) as a Linux daemon or Windows service. You don't need that template to create and run a BackgroundService.

The tutorial Background tasks with hosted services in ASP.NET Core shows how to create and use a BackgroundService but is a bit ... overengineered. The article tries to show too many things at the same time and ends up missing some essential things.

A better introduction is Steve Gordon's What are Worker Services?.

The background service

All that's needed to create a background service, is a class that implements the IHostedService interface. Instead of implementing all the interface methods, it's easier to inherit from the BackgroundService base class and override just the ExecuteAsync method.

The article's example shows this method doesn't need to be anything fancy:

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

That's just a loop with a delay. This will run until the web app terminates and signals the stoppingToken. This service will be created by the DI container, so it can have service dependencies like ILogger or any other singleton service.

Registering the service

The background service needs to be registered as a service in ConfigureServices, the same way any other service is registered. If you have a console application, you configure it in the host's ConfigureServices call. If you have a web application, you need to register it in Startup.ConfigureServices:

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {

        services.AddDbContext<OrdersContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
        
        ...

        //Register the service
        services.AddHostedService<Worker>();

        services.AddRazorPages();
    }

This registers Worker as a service that can be constructed by the DI container and adds it to the list of hosted services that will start once .Run() is called in the web app's Main :

public static void Main(string[] args)
{
    CreateHostBuilder(args).Build().Run();
}

Using DbContext and other scoped services

Adding a DbContext as a dependency is trickier, since DbContext is a scoped service. We can't just inject a DbContext instance and store it in a field - a DbContext is meant to be used as a Unit-of-Work, something that collects all changes made for a single scenario and either commit all of them to the database or discard them. It's meant to be used inside a using block. If we dispose the single DbContext instance we injected though, where do we get a new one?

To solve this, we have to inject the DI service, IServiceProvider, create a scope explicitly and get our DbContext from this scope:

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    private readonly IServiceProvider _services;

    //Inject IServiceProvider
    public Worker(IServiceProvider services, ILogger<Worker> logger)
    {
        _logger = logger;
        _services=services;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            //Create the scope
            using (var scope = _services.CreateScope())
            {
                //Create OrdersContext in the scope
                var ctx = scope.ServiceProvider.GetRequiredService<OrdersContext>();
                
                var latestOrders = await ctx.Orders
                                            .Where(o=>o.Created>=DateTime.Today)
                                            .ToListAsync();
                //Make some changes
                if (allOK)
                {
                    await ctx.SaveChangesAsync();
                }
            }
            //OrdersContext will be disposed when exiting the scope
            ...
        }
    }
}

The OrdersContext will be disposed when the scope exits and any unsaved changes will be discarded.

Nothing says the entire code needs to be inside ExecuteAsync. Once the code starts getting too long, we can easily extract the important code into a separate method :

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

        using (var scope = _services.CreateScope())
        {
            var ctx = scope.ServiceProvider.GetRequiredService<OrdersContext>();
            await DoWorkAsync(ctx,stoppingToken);
        }

        await Task.Delay(1000, stoppingToken);
    }
}

private async Task DoWorkAsync(OrdersContext ctx,CancellationToken stoppingToken)
{
    var latestOrders = await ctx.Orders
                                .Where(o=>o.Created>=DateTime.Today)
                                .ToListAsync();
    //Make some changes
    if (allOK)
    {
        await ctx.SaveChangesAsync();
    }
}