How To Call A Background Task With Hosted Service From .NET Core Web API

Introduction

 

Usually, when we want to do long-running tasks, it's not a good practice to block the user interface for a long time and there is a high chance of getting a timeout exception from the API. The best example is when you want to process excel with huge data, you can upload excel to storage and process it in the background. 

 

In this article, I'm going to explain how to create a background service and invoke that service from the .NET Core web API. Let's go step by step.

 

Step 1 - Create a .NET Core Web API Project

 

In Visual Studio, click on File, go to New, and select the appropriate project template.

 

 

Click on "Next" and enter the project name and create.

 

 

It creates a project and structure that looks like this:

 

 

Step 2 - Create a class library project.

 

Right-click on the solution & add a new class library for hosted service. The project structure looks like shown below:

 

 

Next, install the Hosted service NuGet package by executing the below command in the NuGet package manager console in the class library project:

Install-Package Microsoft.Extensions.Hosting -Version 3.1.2

After executing the command on the console:

 

 

Right-click on the class library project & add an interface with the name "IBackgroundTaskQueue". Right-click & add a new class with the name "BackgroundTaskQueue" and inherit the interface "IBackgroundTaskQueue". Create methods to enqueue & dequeue the requests as shown below.

 

Concurrent Queue is the thread-safe class, used to read & write multiple requests into the queue. It provides the FIFO data structure. If we get multiple requests at the same time, it will put them in the queue & process them one by one.

 

Here SemaphoreSlim is used to set the number of threads run concurrently. For example, if set to 2, if we have 5 requests in the queue, it will pick up 2 in parallel.

public class BackgroundTaskQueue : IBackgroundTaskQueue
   {
       private ConcurrentQueue<Func<CancellationToken, Task>> _workItems =
      new ConcurrentQueue<Func<CancellationToken, Task>>();
       private SemaphoreSlim _signal = new SemaphoreSlim(0);

       public void QueueBackgroundWorkItem(
           Func<CancellationToken, Task> workItem)
       {
           if (workItem == null)
           {
               throw new ArgumentNullException(nameof(workItem));
           }

           _workItems.Enqueue(workItem);
           _signal.Release();
       }

       public async Task<Func<CancellationToken, Task>> DequeueAsync(
           CancellationToken cancellationToken)
       {
           await _signal.WaitAsync(cancellationToken);
           _workItems.TryDequeue(out var workItem);

           return workItem;
       }
   }

Add the method declarations in the interface, this is how the interface looks:

public interface IBackgroundTaskQueue
    {
        void QueueBackgroundWorkItem(Func<CancellationToken, Task> workItem);

        Task<Func<CancellationToken, Task>> DequeueAsync(
            CancellationToken cancellationToken);
    }

Right-click & add a new class with the name "QueuedHostedService" and inherit "BackgroundService" from Microsoft.Extensions.Hosting. Copy-paste the below code into that class.

 

For more details, refer to this link.

public class QueuedHostedService : BackgroundService
    {
        private readonly ILogger _logger;

        public QueuedHostedService(IBackgroundTaskQueue taskQueue,
            ILoggerFactory loggerFactory)
        {
            TaskQueue = taskQueue;
            _logger = loggerFactory.CreateLogger<QueuedHostedService>();
        }

        public IBackgroundTaskQueue TaskQueue { get; }

        protected async override Task ExecuteAsync(
            CancellationToken cancellationToken)
        {
            _logger.LogInformation("Queued Hosted Service is starting.");

            while (!cancellationToken.IsCancellationRequested)
            {
                var workItem = await TaskQueue.DequeueAsync(cancellationToken);

                try
                {
                    await workItem(cancellationToken);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex,
                       "Error occurred executing {WorkItem}.", nameof(workItem));
                }
            }

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

So we are done with the class library. Next, we will see how to invoke & use that in our web API project.

 

Step 3 - Invoke the background service in .NET Core Web API.

 

Right-click on dependencies in the Web API project & add the class library reference to it, as shown in the below screenshot.

 

 

Go to Startup.cs file and inject the below 2 dependencies: 

services.AddHostedService<QueuedHostedService>();
services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();

Next, go to the controller class and inject the "IBackgroundTaskQueue" and invoke the "QueueBackgroundWorkItem" method as shown below.

 

Also, we need to use "IServiceScopeFactory" from Microsoft.Extensions.DependencyInjection because once the API returns its response, all the services including DB context will get disposed of, we need to create again using IServiceScopeFactory. 

public class WeatherForecastController : ControllerBase
    {

        public IBackgroundTaskQueue _queue { get; }
        private readonly IServiceScopeFactory _serviceScopeFactory;
        public WeatherForecastController(IBackgroundTaskQueue queue, IServiceScopeFactory serviceScopeFactory)
        {
            _queue = queue;
            _serviceScopeFactory = serviceScopeFactory;
        }

        [HttpGet]
        public IActionResult Get()
        {
            _queue.QueueBackgroundWorkItem(async token =>
            {
                using (var scope = _serviceScopeFactory.CreateScope())
                {
                    var scopedServices = scope.ServiceProvider;
                    int j = 1000;
                    for (int i = 0; i < j; i++)
                    {
                        Console.WriteLine(i);
                    }
                    await Task.Delay(TimeSpan.FromSeconds(5), token);

                }
            });
            return Ok("In progress..");
        }
    }

Step 4 - Run & Test

 

Once we hit this API, we will get a response as "In progress.." and background tasks invokes & keep running into the for loop which we created. 

 

The API is returned with a message & the background service started running.

 

 

Summary

 

In this article, we discussed how to create a hosted service in .NET Core & how to invoke that background service in the .NET Core Web API. I'm attaching the sample code with this article. I hope this article is useful.