Introduction et implémentation de Hangfire dans l’API Web .NET Core 6

Conditions préalables

Compréhension de base de l’API .NET Core 6 et de C#.
Visual Studio 2022
serveur SQL

Ordre du jour

Créer l’API .NET Core à l’aide de la version 6
Configurer Hangfire dans .NET
Examinez les différents types d’emplois présents dans Hangfire.

Aperçu

Hangfire est open-source et utilisé pour planifier le travail à un événement et à une heure particuliers.
Il est également utilisé pour créer, traiter et gérer vos travaux d’arrière-plan.
Nous l’utilisons dans le traitement en arrière-plan sans intervention de l’utilisateur.
Hangfire est fiable et persistant. Il s’occupera de tout une fois le travail programmé.
Le tableau de bord Hangfire est également disponible pour nous permettre de tout gérer facilement.

Pourquoi Hangfire est requis dans le traitement en arrière-plan

Parfois, nous devons effectuer de longues opérations telles que les mises à jour et la maintenance de la base de données afin qu’elles soient gérées périodiquement.
Importation par lots à partir de fichiers XML, JSON et YAML.
Rapports récurrents sur une base périodique.
Notification de masse sur abonnement et inscription.

Donc, ce sont des choses que nous pouvons faire périodiquement sur une certaine période de temps selon nos besoins.

Il existe différents types d’emplois présents dans Hangfire. Nous allons les regarder un par un.

Emploi feu et oubli

Les tâches Fire and Forget ne sont exécutées qu’une seule fois après certaines conditions que nous fournissons.

Tâche retardée

Un travail différé est également exécuté une seule fois, mais après un intervalle de temps spécifique.

Emploi récurrent

Le travail récurrent est exécuté plusieurs fois après la condition et l’intervalle de temps spécifiés.

Emploi de continuation

Le travail de continuation est exécuté lorsque son travail parent est exécuté et terminé.

Il y a aussi deux emplois présents maintenant dans Hangfire : l’un est Travail par lots et l’autre est Suite de lot, qui sont présents dans la version Hangfire Pro et sont utilisés pour exécuter plusieurs tâches par lots en tant qu’entité unique.

Étape 1

Ouvrez Visual Studio 2022 et créez un nouveau projet d’API Web .NET Core.

Étape 2

Indiquez le nom du projet « HangfireDemo », puis indiquez l’emplacement.

Étape 3

Fournissez des informations supplémentaires telles que .NET Framework 6, configurez HTTPS et activez la prise en charge et le swagger de l’API ouverte.

Étape 4

Installez le package Hangfire NuGet.

Étape 5

Créez un contrôleur d’API et nommez-le « ProductController ».

using Hangfire;
using Microsoft.AspNetCore.Mvc;
namespace HangfireDemo.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        [HttpGet]
        [Route("login")]
        public String Login()
        {
            //Fire - and - Forget Job - this job is executed only once
            var jobId = BackgroundJob.Enqueue(() => Console.WriteLine("Welcome to Shopping World!"));
            return $"Job ID: {jobId}. Welcome mail sent to the user!";
        }
        [HttpGet]
        [Route("productcheckout")]
        public String CheckoutProduct()
        {
            //Delayed Job - this job executed only once but not immedietly after some time.
            var jobId = BackgroundJob.Schedule(() => Console.WriteLine("You checkout new product into your checklist!"),TimeSpan.FromSeconds(20));
            return $"Job ID: {jobId}. You added one product into your checklist successfully!";
        }
        [HttpGet]
        [Route("productpayment")]
        public String ProductPayment()
        {
            //Fire and Forget Job - this job is executed only once
            var parentjobId = BackgroundJob.Enqueue(() => Console.WriteLine("You have done your payment suceessfully!"));
            //Continuations Job - this job executed when its parent job is executed.
            BackgroundJob.ContinueJobWith(parentjobId, () => Console.WriteLine("Product receipt sent!"));
            return "You have done payment and receipt sent on your mail id!";
        }
        [HttpGet]
        [Route("dailyoffers")]
        public String DailyOffers()
        {
            //Recurring Job - this job is executed many times on the specified cron schedule
            RecurringJob.AddOrUpdate(() => Console.WriteLine("Sent similar product offer and suuggestions"), Cron.Daily);
            return "offer sent!";
        }
    }
}

Ici, nous avons créé différents points de terminaison basés sur des scénarios de produit, par exemple lorsqu’un utilisateur se connecte au site d’achat, il reçoit immédiatement un message de bienvenue à l’aide de la tâche Fire-and-Forget.
Après cela, nous avons créé un autre point de terminaison lié à la liste de contrôle du produit. Lorsque l’utilisateur ajoute un nouveau produit à la liste de contrôle, il sera averti et rappelé après quelques secondes que vous ajoutez un nouveau produit à votre liste de contrôle.
Dans le troisième point final, nous avons créé un travail pour le paiement. Lorsque l’utilisateur termine le processus, il reçoit immédiatement un e-mail en utilisant le travail Fire-and-Forget et, plus tard, lorsque ce travail est exécuté, le travail de continuation sera exécuté, qui est le travail enfant et exécuté après le travail parent. sera exécuté.
Enfin, dans le dernier point final, nous voulons envoyer des offres spéciales sur une base mensuelle. Pour cela, nous utilisons une tâche récurrente qui s’exécutera en continu en arrière-plan après des conditions Cron spécifiées.

Étape 6

Enfin, configurons les choses dans les classes Program.cs liées à Hangfire, comme la base de données SQL Server et le middleware, dont nous avons besoin.

using Hangfire;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.

//Hangfire
builder.Services.AddHangfire(x => x.UseSqlServerStorage(@"Data Source=DESKTOP-8RL8JOG;Initial Catalog=hangfire;Integrated Security=True;Pooling=False"));
builder.Services.AddHangfireServer();
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseHangfireDashboard();
app.UseAuthorization();
app.MapControllers();
app.Run();

Nous enregistrons donc ici quelques éléments liés à Hangfire et à la base de données SQL Server.

Étape 7

Maintenant, après avoir exécuté l’application, cette fenêtre Swagger s’ouvrira et, à l’aide de celle-ci, nous effectuerons les opérations une par une après avoir atteint les points de terminaison de l’API.

En outre, il créera les tables suivantes dans la base de données liées à Hangfire pour gérer les travaux.

Étape 8

Vous pouvez désormais également ouvrir le tableau de bord Hangfire pour gérer les tâches exécutées en arrière-plan après avoir atteint le même port API dans une autre fenêtre https://localhost:7204/hangfire.

Nous allons maintenant exécuter les points de terminaison API un par un et vérifier les tâches nouvellement créées dans le tableau de bord Hangfire.

Tout d’abord, lorsque nous atteignons le point de terminaison de connexion à partir de l’interface utilisateur Swagger, il crée une tâche et l’exécute immédiatement, comme indiqué dans les images ci-dessous :

Ici, dans Hangfire Dashboard, vous pouvez voir tous les détails sur les tâches telles que réussies, planifiées, échouées et en cours de traitement, comme je l’ai montré dans les images ci-dessus.

Maintenant, nous atteignons un autre contrôle de produit de point de terminaison et il planifiera une tâche en arrière-plan et s’exécutera une fois après un intervalle de temps spécifié.

Après cela, nous allons atteindre le troisième point final, qui consiste à créer un travail de continuation et à l’exécuter après l’exécution de son travail parent, comme indiqué dans l’image ici. Tout d’abord, le travail parent est exécuté, puis le travail enfant immédiat, qui est le travail de continuation, est exécuté.

Enfin, nous allons atteindre notre dernier point de terminaison API et vérifier comment le travail récurrent est exécuté un par un.