Implement Background Task Using BackgroundService Class In ASP.NET Core

Introduction 

 

If you are new in background task implementation using Background Service class then please read below article so you will get a better understanding for this BackgroundService class in this article with an example.

• Implementation of Background Task using BackgroundService and IHostedService in ASP.NET Core

In this above article, you will get an idea exactly what is BackgroundService and IHostedService. For the implementation of the background task, we dont need any Nuget packages or anything et. It is in core ASP.NET infrastructure itself. We know that the background tasks can be implemented in main two ways in ASP.NET core using BackgroundService Class and IHostedService. BackgroundService class is nothing but an abstract base class.BackgroundService class was present in ASP.NET Core 3.0.It is an abstract base class for implementing long-running services.Using BackgroundService class we can only have one method that needs to be implemented which is ExecuteAsync(CancellationToken cancellationtoken).StartAsync and StopAsync are virtual so you could override it. The default behavior of BackgroundService class is that StartAsync calls ExecuteAsync.If you create a subclass of a BackgroundService, you must implement ExecuteAsync (Because of its Abstract).

 

Let's see this with the below example.

 

In the below example, we are trying to check the status of particular URL, when it is up and when it is down after a specific period of time. If it is up, then we need to write it down in a .txt file, and when it is down, also have it written in a .txt file.

 

Step 1

 

As you can see in below diagram, the BackgroundService class has been implemented:

private readonly ILogger<Worker> _logger;
private HttpClient httpClient;
public Worker(ILogger<Worker> logger)
{
    _logger = logger;
}

public override Task StartAsync(CancellationToken cancellationToken)
{
    httpClient = new HttpClient();
    return base.StartAsync(cancellationToken);
}

public override Task StopAsync(CancellationToken cancellationToken)
{
    httpClient.Dispose();
    return base.StopAsync(cancellationToken);
}

As you can see in the above diagram, in the constructor we initialize a logger for logging output. We also define HttpClient which is a base class for sending HTTP requests and HTTP responses identified by a URI. As you see we implement two methods above StartAsync andStopAsync for our requirement which we need to achieve. Our target is only to run background service and capturing and maintaining status for a particular URL.HttpClient does indirectly implement IDisposable interface the standard usage of HttpClient is not to dispose of it after every request. It releases unmanaged resources used by the HttpClient and optionally disposes of the managed resources.

 

Step 2

 

In the below diagram, as you can see the ExecuteAsync method implementation has main logic.

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while(!stoppingToken.IsCancellationRequested)
            {
                try
                {
                    var result = await httpClient.GetAsync("https://www.c-sharpcorner.com/members/atul-warade");
                    if (result.IsSuccessStatusCode)
                    {
                        _logger.LogInformation("The Website is Up.Status Code {StatusCode}", result.StatusCode);
                    }
                    else
                    {
                        _logger.LogError("The Website is Down.Status Code {StatusCode}", result.StatusCode);
                    }
                }
                catch(Exception ex)
                {
                    _logger.LogError("The Website is Down {0}.", ex.Message);
                }
                finally
                {
                    await Task.Delay(1000 * 5, stoppingToken);
                }

                    //_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);

            }
        }

As you can see above, I tried to check the status for this URL, every 5 seconds for when it is up and when it is down.

 

Step 3

 

As you can see in the below diagram, you need to install Serilog from Nuget for writing texts into a textfile.

 

 

There are two packages which you need:

• Serilog.AspNetCore
• Serilog.Sinks.File

Step 4

 

In the below diagram, you will see I defined a path where our file was stored. In this file, we will get the status of our URL, if it is running or down every 5 seconds.

public static void Main(string[] args)
        {
            Log.Logger = new LoggerConfiguration()
                            .MinimumLevel.Debug()
                            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                            .Enrich.FromLogContext()
                            .WriteTo.File(@"C:\Service\LogFile.txt")
                            .CreateLogger();
            try
            {
                Log.Information("Starting up the Service");
                CreateHostBuilder(args).Build().Run();
                return;
            }
            catch(Exception ex)
            {
                Log.Fatal(ex,"There was a problem starting Service");
                return;
            }
            finally
            {
                Log.CloseAndFlush();
            }

            //CreateHostBuilder(args).Build().Run();
        }

Step 5

 

This is the last step where you will configure your service with Dependency Injection.

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                }).ConfigureServices(services =>
                   services.AddHostedService<Worker>())
                            .UseSerilog();

I hope you will understand this article of BackgroundService Class with an example. Let me know if you are facing any issues while implementing this kind of application. In our next article, we will see a Background Task using IHostedService.