How to create task on startup and stop it on application stop?

Question

I'm using mvc with .net core, I need to run a task on start, and stop it when application stops. In Startup.cs I registered events for application start and stop. The problem is, I don't know how to run a task that has to be run in a specific class from startup. The task looks like this:

public void PreventStatusChange()
    {
        while (forceStatusChange)
        {
            foreach (var ext in GetExtensions())
            {
                ext.Status = StatusType.Available;
            }
            Thread.Sleep(1000);
        }
    }

Variable forceStatusChange is declared in the same class, so I don't see it from my Startup.cs. What is the best way to do it?

Answer 1

You need to create a class that implements IHostedService. This interface defines just two methods, StartAsync which is called when the application starts and StopAsync which is called when it terminates.

You need to register it as a hosted service with :

services.AddHostedService<TimedHostedService>();

Be careful to use AddHostedService, NOT AddSingleton. If you use AddSingleton the runtime won't know to call StartAsync and StopAsync when appropriate.

The article Background tasks with hosted services in ASP.NET Core shows how to implement a service using a timer :

internal class TimedHostedService : IHostedService, IDisposable
{
    private readonly ILogger _logger;
    private Timer _timer;

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

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Timed Background Service is starting.");

        _timer = new Timer(DoWork, null, TimeSpan.Zero, 
            TimeSpan.FromSeconds(10));

        return Task.CompletedTask;
    }

    private void DoWork(object state)
    {
        _logger.LogInformation("Timed Background Service is working.");
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Timed Background Service is stopping.");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

There's nothing particularly interesting in this code - just start a timer when StartAsync is called and stop it on StopAsync

Cancelling long-running tasks

When the runtime needs to recycle or stop, it will call the StopAsync method on all hosted services, wait a while for them to finish gracefully and then warn them to cancel immediatelly. After a short while it will go ahead and terminate the app or recycle it.

The cancellationToken parameter is used to signal that the service should stop immediatelly. Typically, that means that you'd have to write your own code to check it, warn your own task to terminate, wait for all of them to finish etc, similar to the code shown in this article

This is pretty much boilerplate though, which is why the BackgroundService class can be used to create a class that only needs to implement ExecuteAsync(CancellationToken). Starting and stopping that task is provided by BackgroundService, eg :

public class PollingService : BackgroundService
{

    private readonly ILogger _logger;

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

    protected async override Task ExecuteAsync(
        CancellationToken cancellationToken)
    {

        while (!cancellationToken.IsCancellationRequested)
        {

            try
            {
                await DoSomething(cancellationToken);
                await Task.Delay(1000,cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, 
                   $"Error occurred executing {nameof(workItem)}.");
            }
        }

        _logger.LogInformation("Queued Hosted Service is stopping.");
    }        
}

In this case Task.Delay() itself will be cancelled as soon as the runtime raises the cancellation token. DoSomething() itself should be implemented in a way that checks the cancellation token, eg pass it to any asynchronous method that accepts it as a parameter, test the IsCancellationRequested property on every loop and exit it it's raised.

For example :

    protected async override Task ExecuteAsync(
        CancellationToken cancellationToken)
    {

        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                foreach (var ext in GetExtensions())
                {
                    //Oops, time to cancel
                    if(cancellationToken.IsCancellationRequested)
                    {
                        break;
                    }
                    //Otherwise, keep working
                    ext.Status = StatusType.Available;
                }
                await Task.Delay(1000,cancellationToken);
            }
            catch (Exception ex)
            {
                ...
            }
        }

        _logger.LogInformation("Hosted Service is stopping.");
    }        

Answer 2

You can use BackgroundService

public class LongRunningService : BackgroundService
{ 
    public LongRunningService()
    {
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested && forceStatusChange)
        {
            foreach (var ext in GetExtensions())
            {
                ext.Status = StatusType.Available;
            }

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

    protected override async Task StopAsync (CancellationToken stoppingToken)
    {
        // Run your graceful clean-up actions
    }
}

And register it:

public void ConfigureServices(IServiceCollection services)
{
   ...
   services.AddSingleton<IHostedService, LongRunningService>();
   ...
}