Pour t\u00e9l\u00e9charger le code source de cet article, vous pouvez visiter notre r\u00e9f\u00e9rentiel Hangfire avec ASP.NET Core<\/a> .<\/p>\n<\/blockquote>\n\n\n Pour assurer le bon fonctionnement de nos applications et la satisfaction de nos utilisateurs, nous pouvons utiliser pour certaines t\u00e2ches un concept appel\u00e9 traitement en arri\u00e8re-plan. Une t\u00e2che est une m\u00e9thode dans notre code avec une logique que nous devons ex\u00e9cuter. Le traiter en arri\u00e8re-plan signifie que nous pouvons l’ex\u00e9cuter en dehors du thread principal de l’application.<\/p>\n\n\n\n Il existe de nombreuses situations dans lesquelles nous devons garder un travail sp\u00e9cifique loin des projecteurs.<\/p>\n\n\n\n Parfois, il s’agit d’une t\u00e2che de longue haleine dont l’affichage des donn\u00e9es de l’interface utilisateur ne d\u00e9pend pas et qui ralentit le flux de l’application. Un exemple pourrait \u00eatre de t\u00e9l\u00e9charger un tas de photos sur une plate-forme de m\u00e9dias sociaux. Nous ne voudrions pas que cette action emp\u00eache nos utilisateurs d’utiliser la plateforme pendant que nous traitons les photos. Nous pouvons effectuer la t\u00e2che de t\u00e9l\u00e9chargement dans les coulisses et l’utilisateur peut continuer \u00e0 naviguer librement.<\/p>\n\n\n\n Nous pouvons \u00e9galement avoir besoin de planifier certaines t\u00e2ches pour qu’elles s’ex\u00e9cutent toutes les heures, toutes les semaines ou peut-\u00eatre tous les mois. Comme surveiller les utilisateurs inactifs ou envoyer des factures d’abonnement. Ou nous devrons peut-\u00eatre envoyer une notification \u00e0 notre utilisateur une fois, sauf pas maintenant, mais dans environ trois jours.<\/p>\n\n\n\n Nous pouvons g\u00e9rer toutes ces t\u00e2ches avec un bon planificateur de t\u00e2ches en arri\u00e8re-plan qui s’occupe des d\u00e9tails pour nous. C’est l\u00e0 que Hangfire brille.<\/p>\n\n\n\n Hangfire est un planificateur de t\u00e2ches open source et bien document\u00e9 pour ASP.NET et ASP.NET Core. Il est multithread, facilement \u00e9volutif et offre une vari\u00e9t\u00e9 de types de travaux. Il est bien structur\u00e9, simple \u00e0 utiliser et offre des performances puissantes.<\/p>\n\n\n\n Compar\u00e9 aux autres planificateurs disponibles, Hangfire offre de nombreux avantages. Entre autres choses, il est particuli\u00e8rement facile \u00e0 installer et \u00e0 configurer, il utilise un stockage persistant et il dispose d’un joli tableau de bord d’interface utilisateur pour v\u00e9rifier nos travaux \u00e0 tout moment. Il prend en charge le traitement de plusieurs files d’attente et nous pouvons \u00e9galement choisir explicitement la file d’attente que nous voulons utiliser pour un travail sp\u00e9cifique.<\/p>\n\n\n\n Parce que le stockage persistant enregistre l’\u00e9tat du travail, nous avons \u00e9galement un grand bonus – les tentatives de travail. Cette fonctionnalit\u00e9 permet de s’assurer que nos travaux finissent de s’ex\u00e9cuter m\u00eame s’ils rencontrent une exception transitoire ou si le pool d’applications d\u00e9di\u00e9e tombe en panne. Si une t\u00e2che \u00e9choue, Hangfire essaiera de l’ex\u00e9cuter \u00e0 nouveau d\u00e8s que possible.<\/p>\n\n\n\n L’architecture Hangfire comporte trois composants principaux : le client, le serveur et le stockage. Ils sont \u00e9troitement li\u00e9s dans l’ensemble du processus et d\u00e9pendent les uns des autres.<\/p>\n\n\n\n Voyons ce dont chaque composant est responsable :<\/p>\n\n\n\n \u00c9tant donn\u00e9 que Hangfire est con\u00e7u de mani\u00e8re aussi g\u00e9n\u00e9rique que possible, nous pouvons \u00e9galement \u00e9tendre manuellement certaines de ses parties telles que la mise en \u0153uvre du stockage, la cr\u00e9ation de t\u00e2ches ou les processus d’activation de t\u00e2ches pour r\u00e9pondre \u00e0 des besoins sp\u00e9cifiques.<\/p>\n\n\n\n Le flux de travail entre les composants est assez simple :<\/p>\n\n\n\n Une fois que nous avons sp\u00e9cifi\u00e9 notre t\u00e2che dans le code et appel\u00e9 la m\u00e9thode Hangfire appropri\u00e9e pour la cr\u00e9er, le client Hangfire cr\u00e9e la t\u00e2che et la stocke dans la base de donn\u00e9es. Le contr\u00f4le revient ensuite \u00e0 l’application afin que le thread principal puisse poursuivre son travail. On peut repr\u00e9senter ce flux avec quatre actions cons\u00e9cutives dans deux branches diff\u00e9rentes \u2013 une entre client et stockage et l’autre entre stockage et serveur :<\/p>\n\n\n\n Apr\u00e8s avoir appris les m\u00e9canismes de l’architecture Hangfire, voyons comment cela fonctionne dans la pratique.<\/p>\n\n\n\n Pour commencer, cr\u00e9ons un nouveau projet d’API Web ASP.NET Core :<\/p>\n\n\n\n Nous utiliserons \u00e9galement Swagger pour envoyer des requ\u00eates HTTP. Nous pouvons facilement l’ajouter \u00e0 notre .NET 5.0. projet si nous cochons la case Activer le support OpenAPI :<\/p>\n\n\n\n Tout d’abord, nous allons installer le package Hangfire NuGet. Nous pouvons rechercher Hangfire dans le gestionnaire de paquets :<\/p>\n\n\n\n ou ex\u00e9cutez la commande dans la console du gestionnaire de packages :<\/p>\n\n\n\n Apr\u00e8s avoir install\u00e9 ce package, il r\u00e9f\u00e9rence par d\u00e9faut d’autres packages n\u00e9cessaires tels que Hangfire.Core et Hangfire.SqlServer et vous n’avez pas \u00e0 vous en soucier. Pour stocker les d\u00e9finitions et les statuts des t\u00e2ches, comme nous l’avons maintenant appris, Hangfire peut utiliser une base de donn\u00e9es SQL Server par d\u00e9faut et nous pouvons \u00e9galement choisir d’autres options. Dans notre exemple de projet, par souci de simplicit\u00e9, nous allons utiliser le stockage MSSQL LocalDB.<\/p>\n\n\n\n Quel que soit le type de base de donn\u00e9es que nous utilisons, locale ou distante, nous devrions avoir une d\u00e9finition de base de donn\u00e9es – m\u00eame si elle est vide. Hangfire cr\u00e9era les tables dont nous avons besoin pour le stockage des t\u00e2ches, mais il ne peut pas cr\u00e9er de base de donn\u00e9es, nous devons donc la fournir.<\/p>\n\n\n\n Apr\u00e8s avoir configur\u00e9 notre base de donn\u00e9es locale, nous devons mettre \u00e0 jour le fichier appsettings.json<\/em> :<\/p>\n\n\n\n Dans l’objet ConnectionStrings, nous ajoutons notre cha\u00eene de connexion LocalDB. Si vous avez d\u00e9cid\u00e9 d’utiliser une base de donn\u00e9es d\u00e9j\u00e0 existante ou simplement une alternative \u00e0 LocalDB, vous devez modifier la cha\u00eene de connexion pour votre cas sp\u00e9cifique.<\/p>\n\n\n\n Apr\u00e8s avoir install\u00e9 le package Hangfire et configur\u00e9 la base de donn\u00e9es, nous devons \u00e9galement configurer notre classe Startup<\/em> :<\/p>\n\n\n\n Dans la De plus, nous devons mettre \u00e0 jour notre pipeline de traitement des demandes :<\/p>\n\n\n\n Dans la Ce tableau de bord est, par d\u00e9faut, configur\u00e9 pour \u00eatre accessible uniquement localement, mais si vous souhaitez y acc\u00e9der \u00e0 distance, vous pouvez \u00e9galement le configurer. Cependant, il expose de nombreuses informations sensibles, soyez donc toujours prudent avec cette configuration.<\/p>\n\n\n\n Lorsque nous ex\u00e9cutons notre application, Hangfire v\u00e9rifiera automatiquement notre stockage d\u00e9sign\u00e9 pour les tables n\u00e9cessaires, et si elles n’existent pas encore, il les cr\u00e9era pour nous :<\/p>\n\n\n\n C’est tout en ce qui concerne la configuration et nous sommes tous pr\u00eats \u00e0 commencer \u00e0 utiliser Hangfire. Inspectons maintenant rapidement le tableau de bord Hangfire, puis voyons comment cr\u00e9er des t\u00e2ches en arri\u00e8re-plan.<\/p>\n\n\n\n Si nous d\u00e9marrons notre application et naviguons vers l’URL https:\/\/localhost:5001\/hangfire<\/em> , nous pouvons voir le tableau de bord tr\u00e8s utile inclus :<\/p>\n\n\n\n Dans le tableau de bord, nous pouvons voir toutes les t\u00e2ches en cours et planifi\u00e9es que nous cr\u00e9ons avec notre client Hangfire. Nous pouvons \u00e9galement surveiller les serveurs, les tentatives de travail, les travaux \u00e9chou\u00e9s et garder un \u0153il sur tous les travaux dans la file d’attente. Une autre grande chose que nous pouvons faire dans le tableau de bord est que nous pouvons d\u00e9clencher manuellement toutes les t\u00e2ches existantes.<\/p>\n\n\n\n Nous couvrirons les autres onglets un peu plus tard lorsque nous essaierons les diff\u00e9rents types de travaux pris en charge par Hangfire, mais pour l’instant, v\u00e9rifions rapidement l’ onglet Serveurs :<\/em><\/p>\n\n\n\n Ici, nous pouvons voir le serveur qui s’ex\u00e9cute dans notre application de test. Si nous avions plus d’instances de serveur en cours d’ex\u00e9cution, nous les verrions \u00e9galement r\u00e9pertori\u00e9es ici. Hangfire v\u00e9rifie p\u00e9riodiquement l’utilisation du serveur, donc s’il y a un serveur qui n’est plus utilis\u00e9, il sera automatiquement supprim\u00e9 de la liste.<\/p>\n\n\n\n Hangfire prend en charge diff\u00e9rents types de t\u00e2ches que nous pouvons utiliser pour diff\u00e9rentes occasions. Des t\u00e2ches ponctuelles aux t\u00e2ches quotidiennes, nous sommes couverts. Voyons comment les mettre en \u0153uvre facilement et v\u00e9rifier leur ex\u00e9cution dans le tableau de bord.<\/p>\n\n\n\n Pour commencer \u00e0 tester la planification des t\u00e2ches, cr\u00e9ons un dossier Services avec une classe JobTestService<\/em> et son interface d’appartenance :<\/p>\n\n\n\n Tout d’abord, nous sp\u00e9cifions l’ interface IJobTestService<\/em> o\u00f9 nous enregistrons quatre m\u00e9thodes diff\u00e9rentes – nomm\u00e9es de mani\u00e8re pratique d’apr\u00e8s les types de travaux Hangfire.<\/p>\n\n\n\n Apr\u00e8s cela, nous pouvons passer \u00e0 la modification de la classe de service :<\/p>\n\n\n\n Notre classe JobTestService<\/em> impl\u00e9mente l’ interface IJobTestService<\/em> que nous avons cr\u00e9\u00e9e. Chaque m\u00e9thode de la classe n’imprime que du texte sur notre console, au lieu de faire le travail r\u00e9el comme elle le ferait dans une application r\u00e9elle.<\/p>\n\n\n\n Dans le monde r\u00e9el, \u00e0 l’int\u00e9rieur de m\u00e9thodes comme celles-ci, il peut y avoir un code qui t\u00e9l\u00e9charge une photo ou v\u00e9rifie l’inactivit\u00e9 de l’utilisateur. Dans notre exemple, les appels simples Apr\u00e8s avoir d\u00e9fini la classe de service, nous devons \u00e0 nouveau modifier notre classe Startup<\/em> :<\/p>\n\n\n\n Pour pouvoir utiliser notre nouveau service avec injection de d\u00e9pendances, \u00e0 l’int\u00e9rieur de la Le premier type de travail que nous allons couvrir est le travail Fire and Forget. Lorsque nous cr\u00e9ons ce type de job, le serveur ne l’ex\u00e9cute qu’une seule fois, d\u00e8s qu’il le peut.<\/p>\n\n\n\n Dans le dossier Controllers<\/em> de notre application, nous pouvons cr\u00e9er et modifier un fichier JobTestController.cs<\/em> :<\/p>\n\n\n\n Nous cr\u00e9ons le constructeur JobTestController et injectons l’ interface IBackgroundJobClient<\/em> fournie par Hangfire. Nous utiliserons les m\u00e9thodes de cette interface pour planifier diff\u00e9rents types de t\u00e2ches. En plus de cela, nous injectons \u00e9galement l’ interface IJobTestService<\/em> que nous avons cr\u00e9\u00e9e.<\/p>\n\n\n\n Ajoutons maintenant un point de terminaison de test qui nous aidera \u00e0 planifier la t\u00e2che :<\/p>\n\n\n\n Notre nouveau point de terminaison utilise l’interface Hangfire inject\u00e9e pour planifier ce type de t\u00e2che. Nous appelons la m\u00e9thode de l’interface Maintenant, nous pouvons envoyer une requ\u00eate GET \u00e0 ce point de terminaison en utilisant Swagger, et par cons\u00e9quent, cela va cr\u00e9er notre premier travail avec Hangfire !<\/p>\n\n\n\n Apr\u00e8s avoir envoy\u00e9 la demande, v\u00e9rifions le travail dans le tableau de bord. Acc\u00e9dez \u00e0 l’ onglet Jobs , o\u00f9 il devrait maintenant \u00eatre visible sous la section Succeeded<\/em> :<\/p>\n\n\n\n Ici, nous pouvons r\u00e9ex\u00e9cuter manuellement n’importe quel travail r\u00e9ussi si nous le souhaitons, avec le bouton Remettre en file d’attente les<\/em> travaux<\/em> .<\/p>\n\n\n\n Les t\u00e2ches retard\u00e9es sont celles que nous voulons s\u00fbrement ex\u00e9cuter, mais pas tout de suite. Nous pouvons les programmer \u00e0 une certaine heure, peut-\u00eatre dans une minute ou dans trois mois.<\/p>\n\n\n\n Pour tester ce type de job, cr\u00e9ons un nouveau endpoint dans notre JobTestController<\/em> :<\/p>\n\n\n\n Nous ajoutons un point de La D\u00e9sormais, lorsque nous envoyons une requ\u00eate GET \u00e0 ce point de terminaison, nous planifions une t\u00e2che 60 secondes dans le futur. Il s’affiche dans la section Planifi\u00e9e<\/em> de l’ onglet T\u00e2ches du tableau de bord :<\/em><\/p>\n\n\n\n Une fois ex\u00e9cut\u00e9 avec succ\u00e8s, il passe \u00e0 l’ onglet R\u00e9ussi .<\/em><\/p>\n\n\n\n Nous planifions nos t\u00e2ches r\u00e9currentes afin qu’elles puissent se r\u00e9p\u00e9ter \u00e0 un certain intervalle. Pour ces types de t\u00e2ches, Hangfire utilise l’utilitaire logiciel CRON.<\/p>\n\n\n\n Pour planifier ce travail, nous aurons besoin d’une interface Hangfire diff\u00e9rente, alors modifions d’abord le constructeur de notre contr\u00f4leur :<\/p>\n\n\n\n Nous injectons maintenant \u00e9galement l’interface Hangfire IReccuringJobManager<\/em> dans le constructeur. Il expose des m\u00e9thodes utiles pour g\u00e9rer les t\u00e2ches r\u00e9currentes et nous l’utiliserons pour planifier notre nouvelle t\u00e2che.<\/p>\n\n\n\n Nous pouvons maintenant cr\u00e9er un nouveau point de terminaison pour tester la t\u00e2che :<\/p>\n\n\n\n Nous utilisons la m\u00e9thode de l’interface nouvellement inject\u00e9e Apr\u00e8s avoir envoy\u00e9 une requ\u00eate GET au point de terminaison \u00e0 l’aide de Swagger, notre travail r\u00e9current devient visible sous l’ onglet Travaux r\u00e9currents du tableau de bord :<\/em> <\/p>\n\n\n\n Bien que cela montre que nous avons programm\u00e9 notre travail pour qu’il se r\u00e9p\u00e8te \u00e0 l’heure sp\u00e9cifi\u00e9e, chaque fois que le serveur le traite, l’instance trait\u00e9e devient visible dans la section R\u00e9ussite de l’ onglet Travaux .<\/em><\/p>\n\n\n\n Le dernier type de travail que nous allons couvrir est le travail de continuation. Sa principale caract\u00e9ristique est d’encha\u00eener l’ex\u00e9cution des t\u00e2ches. Avec lui, nous pouvons faire en sorte que deux t\u00e2ches s’ex\u00e9cutent l’une apr\u00e8s l’autre en continu.<\/p>\n\n\n\n Nous avons d\u00e9j\u00e0 une m\u00e9thode pour ce type de travail pr\u00e9par\u00e9e dans notre classe de service, modifions donc notre contr\u00f4leur :<\/p>\n\n\n\n Dans le point de Apr\u00e8s avoir atteint ce point de terminaison avec une requ\u00eate GET, si nous v\u00e9rifions la section Succeeded de l’ onglet Jobs<\/em> du Dashboard, nous pouvons voir que nos deux jobs se sont ex\u00e9cut\u00e9s l’un apr\u00e8s l’autre :<\/p>\n\n\n\n Super, tout fonctionne !<\/p>\n\n\n\n Nous avons beaucoup appris sur la biblioth\u00e8que simple et puissante appel\u00e9e Hangfire. Nous savons maintenant comment le configurer dans notre application ASP.NET Core et comment l’utiliser pour planifier diff\u00e9rents types de t\u00e2ches. Il est maintenant temps d’aller planifier des t\u00e2ches en arri\u00e8re-plan !<\/p>\n\n\n\n Jusqu’au prochain article.<\/p>\n\n\n\n Meilleures salutations.<\/p>\n\n\n\n Si vous aimez mes articles, pensez \u00e0 m\u2019acheter quelques caf\u00e9s !<\/strong><\/p>\n\n\n\nIntroduction aux t\u00e2ches en arri\u00e8re-plan<\/h2>\n\n\n\n
Quand devrions-nous utiliser le traitement en arri\u00e8re-plan ?<\/h3>\n\n\n\n
Qu’est-ce que Hangfire ?<\/h2>\n\n\n\n
Caract\u00e9ristiques les plus remarquables de Hangfire<\/h3>\n\n\n\n
Comment fonctionne Hangfire ?<\/h2>\n\n\n\n
Le r\u00f4le de chaque composant<\/h3>\n\n\n\n
\n
Le flux de travail Hangfire<\/h3>\n\n\n\n
Lorsqu’un travail se trouve dans le stockage, le serveur le r\u00e9cup\u00e8re et cr\u00e9e un thread d’arri\u00e8re-plan pour traiter le travail r\u00e9cup\u00e9r\u00e9.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image.png\")
<\/figure>\n\n\n\nConfiguration de Hangfire dans ASP.NET Core<\/h2>\n\n\n\n
![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-1.png\")
<\/figure>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-2.png\")
<\/figure>\n\n\n\nPaquet Hangfire NuGet<\/h3>\n\n\n\n
![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-3.png\")
<\/figure>\n\n\n\nPM> Install-Package Hangfire<\/pre>\n\n\n\n
L’exception est si vous utilisez une option de stockage diff\u00e9rente de SQL Server. Dans ce cas, assurez-vous d’ajouter le package NuGet suppl\u00e9mentaire pour ce type de stockage.<\/p>\n\n\n\nStockage persistant<\/h3>\n\n\n\n
\"AllowedHosts\": \"*\",\n \"ConnectionStrings\": {\n \"DBConnection\": \"Server=(localdb)\\\\MSSQLLocalDB;Database=HangfireApplication;Trusted_Connection=True\"\n }<\/pre>\n\n\n\nClasse de d\u00e9marrage<\/h3>\n\n\n\n
public void ConfigureServices(IServiceCollection services)\n{\n services.AddControllers();\n services.AddSwaggerGen(c =>\n {\n c.SwaggerDoc(\"v1\", new OpenApiInfo { Title = \"HangfireApplication\", Version = \"v1\" });\n });\n services.AddHangfire(x =>\n {\n x.UseSqlServerStorage(Configuration.GetConnectionString(\"DBConnection\"));\n });\n services.AddHangfireServer();\n}<\/pre>\n\n\n\nConfigureServices<\/code>m\u00e9thode, avec la AddHangfire()<\/code>m\u00e9thode, nous ajoutons le service Hangfire avec l’option de stockage SQL Server. Nous fournissons la cha\u00eene de connexion que nous avons sp\u00e9cifi\u00e9e dans le fichier appsettings.json.
Nous ajoutons \u00e9galement le serveur Hangfire avec la AddHangfireServer()<\/code>m\u00e9thode. Le serveur Hangfire de notre projet va vivre \u00e0 l’int\u00e9rieur de l’application.<\/p>\n\n\n\npublic void Configure(IApplicationBuilder app, IWebHostEnvironment env)\n{\n if (env.IsDevelopment())\n {\n app.UseDeveloperExceptionPage();\n app.UseSwagger();\n app.UseSwaggerUI(c => c.SwaggerEndpoint(\"\/swagger\/v1\/swagger.json\", \"HangfireApplication v1\"));\n }\n app.UseHttpsRedirection();\n app.UseRouting();\n app.UseAuthorization();\n app.UseEndpoints(endpoints =>\n {\n endpoints.MapControllers();\n });\n app.UseHangfireDashboard();\n}<\/pre>\n\n\n\nConfigure<\/code>m\u00e9thode, nous ajoutons le tableau de bord Hangfire \u00e0 notre pipeline, en appelant la UseHangfireDashboard()<\/code>m\u00e9thode, afin que nous puissions facilement surveiller nos travaux ult\u00e9rieurement.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-4.png\")
<\/figure>\n\n\n\nTableau de bord Hangfire<\/h2>\n\n\n\n
![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-5.png\")
<\/figure>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-6.png\")
<\/figure>\n\n\n\nTypes d’emplois en arri\u00e8re-plan dans Hangfire<\/h2>\n\n\n\n
public interface IJobTestService\n{\n void FireAndForgetJob();\n void ReccuringJob();\n void DelayedJob();\n void ContinuationJob();\n}<\/pre>\n\n\n\npublic class JobTestService : IJobTestService\n{\n public void FireAndForgetJob()\n {\n Console.WriteLine(\"Hello from a Fire and Forget job!\");\n }\n public void ReccuringJob()\n {\n Console.WriteLine(\"Hello from a Scheduled job!\");\n }\n public void DelayedJob()\n {\n Console.WriteLine(\"Hello from a Delayed job!\");\n }\n public void ContinuationJob()\n {\n Console.WriteLine(\"Hello from a Continuation job!\");\n }\n}<\/pre>\n\n\n\nConsole.WriteLine()<\/code>nous permettront de nous concentrer davantage sur la planification des travaux.<\/p>\n\n\n\npublic void ConfigureServices(IServiceCollection services)\n{\n services.AddControllers();\n services.AddSwaggerGen(c =>\n {\n c.SwaggerDoc(\"v1\", new OpenApiInfo { Title = \"HangfireApplication\", Version = \"v1\" });\n });\n \n services.AddScoped<IJobTestService, JobTestService>();\n services.AddHangfire(x =>\n {\n x.UseSqlServerStorage(Configuration.GetConnectionString(\"DBConnection\"));\n });\n services.AddHangfireServer();\n}<\/pre>\n\n\n\nConfigureServices()<\/code>m\u00e9thode, nous enregistrons notre impl\u00e9mentation d’interface \u00e0 l’aide de la AddScoped()<\/code>m\u00e9thode.<\/p>\n\n\n\nEmplois Fire and Forget<\/h3>\n\n\n\n
[Route(\"api\/[controller]\")]\n[ApiController]\npublic class JobTestController : ControllerBase\n{\n private readonly IJobTestService _jobTestService;\n private readonly IBackgroundJobClient _backgroundJobClient;\n public JobTestController(IJobTestService jobTestService, IBackgroundJobClient backgroundJobClient)\n {\n _jobTestService = jobTestService;\n _backgroundJobClient = backgroundJobClient;\n }<\/pre>\n\n\n\n[HttpGet(\"\/FireAndForgetJob\")]\npublic ActionResult CreateFireAndForgetJob()\n{\n _backgroundJobClient.Enqueue(() => _jobTestService.FireAndForgetJob());\n return Ok();\n}<\/pre>\n\n\n\nEnqueue()<\/code>et lui transmettons notre FireAndForgetJob()<\/code>appel de m\u00e9thode de service en tant que param\u00e8tre.
Cette m\u00e9thode pratique de mise en file d’ attente<\/em> prend soin de cr\u00e9er et d’enregistrer la d\u00e9finition de t\u00e2che dans notre stockage et, bien s\u00fbr, de la mettre en file d’attente pour le traitement.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-7.png\")
<\/figure>\n\n\n\nT\u00e2ches retard\u00e9es<\/h3>\n\n\n\n
[HttpGet(\"\/DelayedJob\")]\npublic ActionResult CreateDelayedJob()\n{\n _backgroundJobClient.Schedule(() => _jobTestService.DelayedJob(), TimeSpan.FromSeconds(60));\n return Ok();\n}<\/pre>\n\n\n\nCreateDelayedJob()<\/code>terminaison, o\u00f9 nous utilisons \u00e0 nouveau l’ interface IBackgroundJobClient<\/em> . Cette fois, cependant, nous n’appelons pas la Enqueue()<\/code>m\u00e9thode. Au lieu de cela, nous utilisons la Schedule()<\/code>m\u00e9thode et nous lui passons deux param\u00e8tres – notre DelayedJob()<\/code>appel de m\u00e9thode de service et le d\u00e9lai.<\/p>\n\n\n\nSchedule()<\/code>m\u00e9thode cr\u00e9era la d\u00e9finition de la t\u00e2che et l’enregistrera, mais elle s’assurera \u00e9galement de la planifier dans la file d’attente \u00e0 l’heure sp\u00e9cifi\u00e9e.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-8.png\")
<\/figure>\n\n\n\nEmplois r\u00e9currents<\/h3>\n\n\n\n
[Route(\"api\/[controller]\")]\n[ApiController]\npublic class JobTestController : ControllerBase\n{\n private readonly IJobTestService _jobTestService;\n private readonly IBackgroundJobClient _backgroundJobClient;\n private readonly IRecurringJobManager _recurringJobManager;\n public JobTestController(IJobTestService jobTestService, IBackgroundJobClient backgroundJobClient, IRecurringJobManager recurringJobManager)\n {\n _jobTestService = jobTestService;\n _backgroundJobClient = backgroundJobClient;\n _recurringJobManager = recurringJobManager;\n }<\/pre>\n\n\n\n[HttpGet(\"\/ReccuringJob\")]\npublic ActionResult CreateReccuringJob()\n{\n _recurringJobManager.AddOrUpdate(\"jobId\", () => _jobTestService.ReccuringJob(), Cron.Minutely);\n return Ok();\n}<\/pre>\n\n\n\nAddOrUpdate()<\/code>. \u00c0 cette m\u00e9thode, nous transmettons un identifiant de travail de choix, notre RecurringJob()<\/code>appel de m\u00e9thode et l’intervalle CRON.
La m\u00e9thode hangfire cr\u00e9era une nouvelle t\u00e2che avec l’identifiant sp\u00e9cifi\u00e9 ou mettra \u00e0 jour une t\u00e2che existante. Dans cet exemple, nous allons simplement cr\u00e9er le travail pour la premi\u00e8re fois.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-9.png\")
<\/figure>\n\n\n\nEmplois de continuation<\/h3>\n\n\n\n
[HttpGet(\"\/ContinuationJob\")]\npublic ActionResult CreateContinuationJob()\n{\n var parentJobId = _backgroundJobClient.Enqueue(() => _jobTestService.FireAndForgetJob());\n _backgroundJobClient.ContinueJobWith(parentJobId, () => _jobTestService.ContinuationJob());\n \n return Ok();\n}<\/pre>\n\n\n\nCreateContinuationJob()<\/code>terminaison, nous utilisons \u00e0 nouveau l’interface Hangfire IBackgroundJobClient<\/em> . Nous l’utilisons d’abord pour cr\u00e9er un simple travail Fire and Forget – maintenant nous savons comment faire cela :).
Nous voulons que cette t\u00e2che soit un d\u00e9clencheur pour la t\u00e2che suivante, nous nous assurons donc de collecter l’identifiant Enqueue()<\/code>renvoy\u00e9 par la m\u00e9thode. Apr\u00e8s sa cr\u00e9ation, nous appelons la m\u00e9thode de l’interface ContinueJobWith()<\/code>et transmettons l’ID de travail du travail cr\u00e9\u00e9 avec notre ContinuationJob()<\/code>appel de m\u00e9thode. La ContinueJobWith()<\/code>m\u00e9thode fera en sorte d’encha\u00eener nos deux jobs ensemble.<\/p>\n\n\n\n![\"Hangfire](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/10\/image-10.png\")
<\/figure>\n\n\n\nConclusion<\/h2>\n\n\n\n
Dernier articles<\/h2>\n\n\n\n
\n
Vous aimez le contenu ?<\/strong><\/h2>\n\n\n\n
\n\n\n\n