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

Veerendra Annigere

Call background service from web APICall background task from web APIHosted Service in .NET CoreWorker service in .NET Core

4 Comments

Join the conversation! Your thoughts help the community grow.

Carlin Anderson3y ago
Is there an update for this with core 6/7? There are some differences in the worker service class setup from what I can tell. My app has both razor and API support so that may be a difference for a default API startup - when I try to explicitly call a method to trigger the service startup, I get this error. An unhandled exception occurred while processing the request.InvalidOperationException: Unable to resolve service for type 'BackgroundWorkerService.iBackgroundTaskQueue' while attempting to activate <MyAPI.controllers.controllername> Microsoft.Extensions.DependencyInjection.ActivatorUtilities.GetService(IServiceProvider sp, Type type, Type requiredBy, bool isDefaultParameterRequired)
Amol Bankar3y ago
I followed same steps, i have function in ServiceClass which pulls data from one another and push into our db using EF Core Entity Framework. I invoked this function in Web API in USING scope. But in ServiceClass function, when i try to data from another db it gives exception that database Context has been disposed "ChangeTracker = 'Context.ChangeTracker' threw an exception of type 'System.ObjectDisposedException". Please help.
Jonathan Jones4y ago
How would this code work in a load balanced environment. Would there be any issues?
Greg Horvath5y ago
Your post mentions that this code runs the enqueued tasks concurrently, but it does not appear that this is the case as the main loop in your processor awaits the result of the task.

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.