DEV Community: Jobsity

Getting Started with Background Tasks In ASP.NET Core WebAPI

Jobsity — Wed, 30 Mar 2022 22:34:18 +0000

If you are building a web application, you may have encountered scenarios where some operation needs to be performed indefinitely. So how to handle such scenarios? An efficient way to tackle such scenarios is by using background services. In this tutorial, we will be learning how to create background services in the .NET Core web applications. The .NET Core is Microsoft's offering for building cross-platform applications and now its gaining popularity more than ever.

But first, let's understand more about background services below:

A Short Introduction to Background Services

First, let us discuss why do we need background tasks. In any application, there is a main thread that is responsible for the execution of the application. This thread accepts the requests, performs logic, and finally returns the output.

But there are scenarios where you don't want to delegate your jobs to this main thread. For instance:

You have to process images or manipulation of media. Image processing and image manipulation, for instance, is a resource extensive task; hence it is more suited for background operation.
You might want to schedule some jobs for some specific time of day or at any particular time of day. For example, you might need to send the emails to your subscribers at midnight. Background jobs offer a perfect solution for this.
You have to continuously listen for some event. This event can be either internal or external. For example, you might have an application that reacts to the change in the forex rates. So this process runs throughout the lifetime of the application. Hence we can initiate this process in the background and let it listen.
You have to perform IO operations that are extensive such as reading the disk for files. Reading lengthy files, which can be from gigabytes to terabytes, if we perform this operation on the main thread, it will freeze the application resulting in a downgraded user experience. Hence having background service taking care of this extensive task provides a smoother user experience.
You want to periodically perform house keeping operations such as database cleaning, update secondary database or garbage collections operations.

Options Available

Now that you are equipped about the background tasks, let's look at the options available to you to build them. The .NET Core offers three classes to assist you with it: IHostedService and BackgroundService.

Other options are not offered by .NET Core, rather third party offerings. You can use the Hangfire library or opt for some cloud based solution.

Here in this tutorial, we will stick to the solutions provided by the .NET Core.

We will be creating a service that continuously prints out time after every second until the application shuts down.

IHostedService

The IHostedService is an interface that provides the base for implementing the background services or tasks. For any class to operate as a background service, it must implement this interface. Once implemented, the implementing class has to override two methods: StartAsync(CancellationToken) and StopAsync(CancellationToken).

Next, this hosted service must be registered in the application during the startup of the application. You can register the hosted service in the application by calling the method: AddHostedService<Your_Class>().

Let's create our service using `IHostedService`

For the sake of simplicity, I am using the ASP.NET Core WebAPI project. You can create a new project in Visual Studio to get started.

Now within this project, create a new file called ImplementIHostedService.cs. This class is basically our service and it implements the IHostedService interface. Add the below code in this file:

using Microsoft.Extensions.Hosting;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace WebApplication3.Services
{
    public class ImplementIHostedService : IHostedService
    {
        public Task StartAsync(CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    Console.WriteLine($"Respponse from IHostedService - {DateTime.Now}");
                    await Task.Delay(1000);
                }
            });

            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            Console.WriteLine("Shutting down IHostedService");
            return Task.CompletedTask;
        }
    }
}

Next, you will need to register this service in the service registration. Open the Startup.cs file and add the below line in the ConfigureServices method:

services.AddHostedService<ImplementIHostedService>();

Now run the project and you will see the console returning back the output after one-second delay. If you close the application you will see the output Shutting down IHostedService message.

To summarize:

First we create the class that represents our background service.
Next, we implement the IHostedService in this class.
You will need to override two critical methods in your class: StartAsync and StopAsync.
In the StartAsync, we fire a new task that performs the background job for us. This task runs in the background and perform the long running operation.
Finally, we override the StopAsync method. We do this to handle any clean up tasks when the application is shut down.

Let's create our service using `BackgroundService`

Here, we will create the same functionality by inheriting BackgroundService. The BackgroundService is an abstract class provided by .NET Core that implements IHostedService but conceals the mechanics behind it. As we shall see the implementation becomes very clean in BackgrounfService.

In your ASP.NET Core WebApi project, create a new file called ImplementBackgroundService.cs. Add the below code in this file:

using Microsoft.Extensions.Hosting;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace WebApplication3.Services
{
    public class ImplementBackgroundService : BackgroundService
    {
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                Console.WriteLine($"Respponse from Background Service - {DateTime.Now}");
                await Task.Delay(1000);
            }
        }
    }
}

Here we do not have to worry about the StartAsync or StopAsync methods. Rather, we have a single method called ExecuteAsync. We override this method to add our functionality. The point to note here is we do not have to create a new Task when working with BackgroundService. Rather the service works in the background.

Finally, we have to register our service in the Startup.cs file. Add the below line of code in the method ConfigureServices of the Startup.cs file:

services.AddHostedService<ImplementBackgroundService>();

Run the application and you will see the similar output here as well.

When to Use `IHostedService` and `BackgroundService`

`IHostedService`

The IHostedService provides the basic framework for building the background operations. It gives developers the control to begin and end the operations. Having this control allows development of complex scenarios where manual tweaks are needed. Developers opt for this way when they need to build scenarios that are complex and require careful implementation for starting and stopping of the service.

`BackgroundService`

The BackgroundService abstracts the working of the code and provides a simple way to initiate long-running tasks. For scenarios that are simple and do not require much tweaking, BackgroundService offers a readily available solution to jump-start the development. Therefore developers prefer it when they just want to get started with the task without having to worry much about the mechanics.

Conclusion

In this tutorial, we looked at how we can setup background tasks. These tasks are very helpful in running and processing the information concealed from the user. If properly used, these services can drastically improve the overall experience of the web application and make the processing faster. You can handle long running tasks that require huge computing resources and memory in efficient manner.
--
Feel free to browse through the other sections of the blog where you can find many other amazing articles on Programming and IT!

And if you are interested in joining our amazing team and working with top U.S. based clients, then apply here and take your career to the next level.

How to Use Regular Expressions in Python

Jobsity — Fri, 25 Feb 2022 23:11:25 +0000

In Python, Regular Expressions are also known as RegEx. RegEx is a unique text string used for defining a search pattern. Regular Expression is beneficial for extracting information from text such as code, files, logs, spreadsheets, or even documents. In simple words, RegEx is a combination of letters, symbols, and numbers you can use to search for things within a longer text.

This article sheds light on the usage of Regular Expression using Python.

While you are using the Regular Expression in Python, the first and foremost thing is to understand that everything is a character, and you are reproducing patterns to match a specific sequence of characters also regarded as strings.

In the programming world, both newbie and experienced developers often ask how vital learning RegEx is. Today our quest is to find out the importance of RegEx in the context of development with some simple and relevant examples.

Let me introduce some fundamental metacharacters in RegEx and their purpose of use. To know more about RegEx syntax, you may check the Official Documentation.

Character(s)	What it does in Python
. - A period.	Matches up any single character except the newline character.
^ - A caret.	Matches up a pattern at the start of the string.
\A - Uppercase A.	It matches up only at the start of the string.
$ - Dollar sign.	Matches the end of the string.
\Z - Uppercase Z.	It matches up only at the end of the string.
[]	It matches the set of characters you specify within it.
\ - Backslash.	Used to drop the special meaning of character following it
\w - Lowercase w.	It matches any single letter, digit, or underscore.
\W - Uppercase W.	Matches any character not part of \w.
\s - Lowercase s.	Matches up a single whitespace character like space, newline, tab, return.
\S - Uppercase S.	It matches up any character that is not a part of \s.
\d - Lowercase d.	Matches decimal digit 0-9.
\D - Uppercase D.	It matches any character that is not a decimal digit.
\t - Lowercase t.	Matches tab.
\n - Lowercase n.	Matches newline.
\r - Lowercase r.	Matches return.
\b - Lowercase b.	It matches up only the beginning or end of the word.
+	Checks if the preceding character appears single or multiple times.
*	Scrutinizes if the preceding character appears zero or more times.
?	Matches zero or one occurrence.
{}	Checks for an explicit number of times.
()	Creates a group when performing matches.
<>	Creates a named group when performing matches.

Note: The above table doesn't shed light on every aspect of RegEx. Don't bother if you can't wrap your head around all the meta-characters for now. With time and training, you will understand the uniqueness of these characters and learn when to use them.

Python comes with a module named re to work with RegEx. The basic syntax of importing the RegEx module is:

import re

The RegEx mechanism comes with the module named re, and it provides many functions. In this tutorial, I’m going to discuss the three most practical and widely used functions.

re.match() Function

The re.match() function of the re module in Python searches for the regular expression pattern and returns the first occurrence. The Python RegEx Match function checks for a match only at the beginning of the string. Therefore, if a match is found in the first line, it immediately returns the matched object. However, if a match is seen in another line, the Python RegEx Match function returns null. Please allow me to show you a quick example now.

import re 
pattern = "C" 
sequence1 = "IceCream" 
sequence2 = "Catch" 
print("Sequence 1: ", re.match(pattern, sequence1)) 
print("Sequence 2: ", re.match(pattern,sequence2).group())

Output:

Sequence 1:  None 
Sequence 2:  C

In the above example, the function re.match()returns a corresponding match object if zero or more characters (C) at the beginning of the string match the pattern. Else it returns None if the string does not match the given pattern. As you can see, we get an output of None because it didn't find the pattern at the beginning of the first occurrence.

re.search() Function

The re.search() function searches for the regular expression pattern and returns the first occurrence in a string. Unlike the re.match() function, it checks all lines of the input string. The Python re.search() function returns a match object when the pattern is found and is "null” if the pattern is not found in the string.

Here is a simple example for your better understanding.

import re 
patterns = ["Software testing", "Dan"] 
my_string = "Software testing is a tough job" 
for pattern in patterns: 
    print("Looking for '%s' in '%s' " % (pattern, my_string), end='') 


    if re.search(pattern,my_string):

print("Here is a match case") 
    else:

print("Not a match")

Output:

Looking for 'Software testing' in 'Software testing is a tough job' Here is a match case 
Looking for 'Dan' in 'Software testing is a tough job' Not a match

I set two patterns in the above python program and searched them into my_string. For the first case, the function got a matching case. Therefore, it returned positive and negative for the second case.

re.findall() Function

In Python, the re.findall() method returns a list of strings containing all the matching cases from the input text upon provided pattern. The re.search() method quickly searches the provided text using the specified pattern and returns only the first occurrence. In contrast, the re.findall() function iterates over all the lines of the file and returns all the non-overlapping matches of pattern in a single step. If the pattern is not found in the text, re.findall() returns an empty list.

Let’s write a simple python program to understand the **re.findall() **function’s behavior.

import re 
my_string1 = "Hello 10 Dan 20. Howdy? 30" 
my_string2 = "Hello Dan Howdy?" 
pattern = '\d+' 
result1 = re.findall(pattern, my_string1) 
result2 = re.findall(pattern, my_string2) 
print(result1) 
print(result2)

Output:

['10', '20', '30'] 
[]

If you look closely into the above example, you'll find two different strings declared against a single pattern. For the first string, the re.findall() function got a match and returned the value ['10', '20', '30'] as per the pattern demand. On the other hand, the second string did not have the pattern available in it. Therefore, the function returned an empty list [].

Regular Expression is a vast topic, and it requires a lot of practice to become a master of it. In this tutorial, I tried to give you a quick review of RegEx and its essential functions. However, it has many advanced-level functions that you will know later on. Being proficient in RegEx and its functions, solving exercise is a must!

Feel free to browse through the other sections of the blog where you can find many other amazing articles on: Programming, IT, Outsourcing, and even Management.

Interested in joining our amazing team and working with top U.S. based clients? Then apply here and take your career to the next level.

DEV Community: Jobsity

Getting Started with Background Tasks In ASP.NET Core WebAPI

A Short Introduction to Background Services

Options Available

IHostedService

Let's create our service using IHostedService

Let's create our service using BackgroundService

When to Use IHostedService and BackgroundService

IHostedService

BackgroundService

Conclusion

How to Use Regular Expressions in Python

re.match() Function

re.search() Function

re.findall() Function

Let's create our service using `IHostedService`

Let's create our service using `BackgroundService`

When to Use `IHostedService` and `BackgroundService`

`IHostedService`

`BackgroundService`