Le développement d'applications modernes nécessite souvent le traitement de tâches d'arrière-plan pour gérer des tâches volumineuses. Dans ce scénario, nous avons besoin de gestionnaires de tâches d'arrière-plan pour exécuter plusieurs tâches. Il existe de nombreux gestionnaires de tâches, et l'un des gestionnaires de tâches de fond de base pour les applications C# .NET Core est Hangfire. Dans ce blog, nous allons apprendre à connaître le traitement de tâches en arrière-plan avec Hangfire et comment l'utiliser avec d'autres packages comme IronPDF for PDF Generation pour générer des documents PDF en arrière-plan.

Introduction

Hangfire simplifie la mise en œuvre du traitement en arrière-plan dans les applications ASP.NET Core ou .NET Core 6 Web API en fournissant un cadre fiable et flexible pour la gestion et l'exécution des tâches en arrière-plan. Hangfire est disponible en tant que package NuGet et peut être installé en utilisant la CLI .NET comme ci-dessous.

dotnet add package Hangfire --version 1.8.6

Mise en œuvre dans l'API Web de .NET Core

Pour découvrir Hangfire, créons une simple application .NET Core API et installons Hangfire à l'aide de la CLI.

dotnet new webapi -n HangfireDemo
cd HangfireDemo
dotnet build
dotnet add package Hangfire --version 1.8.6
dotnet build

Nous créons ici une API REST météorologique simple à l'aide de .NET CLI. La première ligne crée un projet Core Web API nommé HangfireDemo (peut également créer ASP.NET Core) pour exécuter des points de terminaison API. La deuxième ligne permet de naviguer dans le dossier "HangfireDemo" que nous venons de créer et de construire le projet. Ensuite, nous avons ajouté le paquet NuGet Hangfire à notre projet et l'avons à nouveau construit. Après cela, vous pouvez ouvrir votre projet dans l'éditeur de votre choix, Visual Studio 2022 ou JetBrains Rider. Maintenant, si vous exécutez le projet, vous pouvez voir le Swagger comme ci-dessous.

Ici, nous pouvons voir les API GET météo qui renvoient la date, le résumé et la température.

Ajoutons maintenant un processeur de tâches d'arrière-plan Hangfire. Ouvrir le projet dans Visual Studio.

Ajouter un processeur de travail Hangfire

Configurez Hangfire dans votre application, généralement dans le fichier Startup.cs. Cela implique la mise en place d'un stockage de tâches et l'initialisation du serveur Hangfire.

// Startup.cs
using Hangfire;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Hangfire services
        services.AddHangfire(config => config.UseSqlServerStorage("your_connection_string"));
    }
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Configure Hangfire
        app.UseHangfireServer();
        app.UseHangfireDashboard();
        // Your other configuration settings
    }
}

// Startup.cs
using Hangfire;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Hangfire services
        services.AddHangfire(config => config.UseSqlServerStorage("your_connection_string"));
    }
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Configure Hangfire
        app.UseHangfireServer();
        app.UseHangfireDashboard();
        // Your other configuration settings
    }
}

' Startup.cs
Imports Hangfire
Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		' Add Hangfire services
		services.AddHangfire(Function(config) config.UseSqlServerStorage("your_connection_string"))
	End Sub
	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IHostingEnvironment)
		' Configure Hangfire
		app.UseHangfireServer()
		app.UseHangfireDashboard()
		' Your other configuration settings
	End Sub
End Class

ConfigureServices est utilisé pour ajouter un espace de stockage afin de sauvegarder les emplois nouvellement créés par Hangfire. Ici, la base de données SQL Server est utilisée. La chaîne de connexion du serveur SQL doit être remplacée par "your_connection_string". Il est également possible d'utiliser le stockage en mémoire avec Hangfire.InMemory.

dotnet add package Hangfire.InMemory --version 0.6.0

Et remplacer par

services.AddHangfire(configuration => { configuration.UseInMemoryStorage(); });

services.AddHangfire(configuration => { configuration.UseInMemoryStorage(); });

services.AddHangfire(Sub(configuration)
	configuration.UseInMemoryStorage()
End Sub)

Créer des emplois d'arrière-plan

Définissez les méthodes que vous souhaitez exécuter en arrière-plan. Ces méthodes doivent être des méthodes statiques ou des méthodes d'instance d'une classe avec un constructeur sans paramètre. Les tâches peuvent être exécutées de manière récurrente ou en plusieurs fois.

public class MyBackgroundJob
{
    public void ProcessJob()
    {
        // Your background job logic, recurring job or multiple jobs
        Console.WriteLine("Background job is running...");
    }
}

public class MyBackgroundJob
{
    public void ProcessJob()
    {
        // Your background job logic, recurring job or multiple jobs
        Console.WriteLine("Background job is running...");
    }
}

Public Class MyBackgroundJob
	Public Sub ProcessJob()
		' Your background job logic, recurring job or multiple jobs
		Console.WriteLine("Background job is running...")
	End Sub
End Class

Mise en file d'attente des emplois

Mise en file d'attente des tâches d'arrière-plan à l'aide de l'API Hangfire. Vous pouvez programmer l'exécution des tâches d'arrière-plan à une heure précise, après un certain délai ou régulièrement.

// Enqueue a job to run immediately
BackgroundJob.Enqueue<MyBackgroundJob>(x => x.ProcessJob());
// Schedule a job to run after 5 min delay, delayed job
BackgroundJob.Schedule<MyBackgroundJob>(x => x.ProcessJob(), TimeSpan.FromMinutes(5));
// Schedule a recurring job / recurring jobs using job Id
RecurringJob.AddOrUpdate<MyBackgroundJob>("job Id", x => x.ProcessJob(), Cron.Daily);

// Enqueue a job to run immediately
BackgroundJob.Enqueue<MyBackgroundJob>(x => x.ProcessJob());
// Schedule a job to run after 5 min delay, delayed job
BackgroundJob.Schedule<MyBackgroundJob>(x => x.ProcessJob(), TimeSpan.FromMinutes(5));
// Schedule a recurring job / recurring jobs using job Id
RecurringJob.AddOrUpdate<MyBackgroundJob>("job Id", x => x.ProcessJob(), Cron.Daily);

' Enqueue a job to run immediately
BackgroundJob.Enqueue(Of MyBackgroundJob)(Function(x) x.ProcessJob())
' Schedule a job to run after 5 min delay, delayed job
BackgroundJob.Schedule(Of MyBackgroundJob)(Function(x) x.ProcessJob(), TimeSpan.FromMinutes(5))
' Schedule a recurring job / recurring jobs using job Id
RecurringJob.AddOrUpdate(Of MyBackgroundJob)("job Id", Function(x) x.ProcessJob(), Cron.Daily)

Tableau de bord et serveur Hangfire

Le tableau de bord et le serveur Hangfire peuvent être ajoutés dans la méthode Configurer.

// Run Hangfire server
app.UseHangfireServer();
app.UseHangfireDashboard();

// Run Hangfire server
app.UseHangfireServer();
app.UseHangfireDashboard();

' Run Hangfire server
app.UseHangfireServer()
app.UseHangfireDashboard()

Le serveur peut également être ajouté dans ConfigureServices.

services.AddHangfireServer();

services.AddHangfireServer();

services.AddHangfireServer()

Emplois "Fire and Forget

//Fire and forget job / Fire and forget jobs are executed only once and almost immediately after creation.
var jobId = BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget!")); //jobId for Fire and forget job

//Fire and forget job / Fire and forget jobs are executed only once and almost immediately after creation.
var jobId = BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget!")); //jobId for Fire and forget job

'Fire and forget job / Fire and forget jobs are executed only once and almost immediately after creation.
Dim jobId = BackgroundJob.Enqueue(Sub() Console.WriteLine("Fire-and-forget!")) 'jobId for Fire and forget job

Emplois récurrents

//Recurring jobs fire many times on the specified CRON schedule.
RecurringJob.AddOrUpdate( "myrecurringjob",() => Console.WriteLine("Recurring!"),Cron.Daily);

//Recurring jobs fire many times on the specified CRON schedule.
RecurringJob.AddOrUpdate( "myrecurringjob",() => Console.WriteLine("Recurring!"),Cron.Daily);

'Recurring jobs fire many times on the specified CRON schedule.
RecurringJob.AddOrUpdate("myrecurringjob",Sub() Console.WriteLine("Recurring!"),Cron.Daily)

Emplois retardés

//Delayed jobs are executed only once too, but not immediately, after a certain specific interval.
var jobId = BackgroundJob.Schedule(() => Console.WriteLine("Delayed!"),
    TimeSpan.FromDays(7));

//Delayed jobs are executed only once too, but not immediately, after a certain specific interval.
var jobId = BackgroundJob.Schedule(() => Console.WriteLine("Delayed!"),
    TimeSpan.FromDays(7));

'Delayed jobs are executed only once too, but not immediately, after a certain specific interval.
Dim jobId = BackgroundJob.Schedule(Sub() Console.WriteLine("Delayed!"), TimeSpan.FromDays(7))

Continuations

//Continuation jobs are executed when its parent job has been finished, immediate child job
BackgroundJob.ContinueJobWith(jobId,() => Console.WriteLine("Continuation!"));

//Continuation jobs are executed when its parent job has been finished, immediate child job
BackgroundJob.ContinueJobWith(jobId,() => Console.WriteLine("Continuation!"));

'Continuation jobs are executed when its parent job has been finished, immediate child job
BackgroundJob.ContinueJobWith(jobId,Sub() Console.WriteLine("Continuation!"))

Travail par lots

//Batch is a group of background jobs that is created atomically and considered as a single entity. Two jobs can be run as below.
var batchId = BatchJob.StartNew(x =>
{
    x.Enqueue(() => Console.WriteLine("Job 1"));
    x.Enqueue(() => Console.WriteLine("Job 2"));
});

//Batch is a group of background jobs that is created atomically and considered as a single entity. Two jobs can be run as below.
var batchId = BatchJob.StartNew(x =>
{
    x.Enqueue(() => Console.WriteLine("Job 1"));
    x.Enqueue(() => Console.WriteLine("Job 2"));
});

'Batch is a group of background jobs that is created atomically and considered as a single entity. Two jobs can be run as below.
Dim batchId = BatchJob.StartNew(Sub(x)
	x.Enqueue(Sub() Console.WriteLine("Job 1"))
	x.Enqueue(Sub() Console.WriteLine("Job 2"))
End Sub)

Travail de continuation de lot

Batch continuation is fired when all background jobs in a parent batch are finished.
BatchJob.ContinueBatchWith(batchId, x =>
{
    x.Enqueue(() => Console.WriteLine("Last Job"));
});

Batch continuation is fired when all background jobs in a parent batch are finished.
BatchJob.ContinueBatchWith(batchId, x =>
{
    x.Enqueue(() => Console.WriteLine("Last Job"));
});

Dim tempVar As Boolean = TypeOf continuation Is fired
Dim [when] As fired = If(tempVar, CType(continuation, fired), Nothing)
Batch tempVar all background jobs in a parent batch are finished.BatchJob.ContinueBatchWith(batchId, Sub(x)
	x.Enqueue(Sub() Console.WriteLine("Last Job"))
End Sub)

Tableau de bord

Le tableau de bord Hangfire est l'endroit où vous pouvez trouver toutes les informations sur vos jobs d'arrière-plan. C'est écrit comme un middleware OWIN (si vous n'êtes pas familier avec OWIN, ne vous inquiétez pas), vous pouvez donc l'intégrer dans votre application ASP.NET, ASP.NET MVC, Nancy et ServiceStack, ainsi qu'utiliser la fonction OWIN Self-Host pour héberger le tableau de bord à l'intérieur des applications Console ou dans les services Windows.

Lorsque vous avez le tableau de bord activé dans votre vue, le tableau de bord se trouve à l'extension /hangfire/. Ce tableau de bord permet de gérer les tâches d'arrière-plan, de planifier les tâches d'arrière-plan, d'afficher les tâches à supprimer et à oublier, ainsi que les tâches récurrentes. Les travaux peuvent être identifiés à l'aide de l'ID du travail.

Traitement en direct

Emplois réussis

Les emplois retenus peuvent être consultés ci-dessous.

Travaux programmés

Maintenant, lorsque votre application s'exécute, Hangfire se charge de traiter les tâches d'arrière-plan en fonction des paramètres configurés.

N'oubliez pas de consulter la documentation de Hangfire pour des options de configuration et des fonctionnalités plus avancées : Hangfire Documentation et le code complet est disponible sur GitHub Hangfire Demo.

Présentation d'IronPDF

IronPDF for .NET PDF Generation est un package NuGet de la bibliothèque PDF d'Iron Software qui aide à lire et à générer des documents PDF. Il peut convertir en PDF des documents facilement formatés avec des informations de style. IronPDF peut facilement générer des PDF à partir de contenu HTML. Il peut télécharger le code HTML à partir de l'URL et générer ensuite des PDF.

L'attraction principale d'IronPDF est sa fonction de conversion HTML en PDF, qui préserve les mises en page et les styles. Il peut créer des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Cette fonction permet de convertir des fichiers HTML, des URL et des chaînes HTML en PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Commencez avec IronPDF

Commencez à utiliser IronPDF dans votre projet dès aujourd'hui avec un essai gratuit.

Première étape :

Commencer gratuitement

Installer la bibliothèque IronPDF

Installation à l'aide du gestionnaire de paquets NuGet

Pour intégrer IronPDF à votre projet .NET à l'aide du gestionnaire de paquets NuGet, procédez comme suit :

1. Ouvrez Visual Studio et dans l'explorateur de solutions, faites un clic droit sur votre projet.

2. Choisissez "Gérer les paquets NuGet..." dans le menu contextuel.

3. Allez dans l'onglet Parcourir et recherchez IronPDF.

4. Sélectionnez la bibliothèque IronPDF dans les résultats de la recherche et cliquez sur le bouton d'installation.

5. Accepter tout accord de licence.

   Si vous souhaitez inclure IronPDF dans votre projet via la console du gestionnaire de paquets, exécutez la commande suivante dans la console du gestionnaire de paquets :

Install-Package IronPdf

Il récupérera et installera IronPDF dans votre projet.

Installation à l'aide du site NuGet

Pour une présentation détaillée d'IronPDF, notamment de ses caractéristiques, de sa compatibilité et des options de téléchargement supplémentaires, visitez la page IronPDF sur le site Web de NuGet à l'adresse https://www.nuget.org/packages/IronPdf.

Installation par DLL

Alternativement, vous pouvez intégrer IronPDF directement dans votre projet en utilisant son fichier dll. Téléchargez le fichier ZIP contenant le DLL depuis ce téléchargement direct IronPDF. Décompressez-la et incluez la DLL dans votre projet.

Modifions maintenant notre application pour ajouter une tâche de traitement en arrière-plan afin de télécharger un site web de pipeline de requêtes HTTP sous forme de fichier PDF.

namespace HangfireDemo.Core;
public class PdfGenerationJob
{
    public void Start(string website)
    {
        // Create a PDF from any existing web page
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = renderer.RenderUrlAsPdf(website);
        var filePath = AppContext.BaseDirectory + "result.pdf";
        pdf.SaveAs(filePath);
    }
}

namespace HangfireDemo.Core;
public class PdfGenerationJob
{
    public void Start(string website)
    {
        // Create a PDF from any existing web page
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = renderer.RenderUrlAsPdf(website);
        var filePath = AppContext.BaseDirectory + "result.pdf";
        pdf.SaveAs(filePath);
    }
}

Namespace HangfireDemo.Core
	Public Class PdfGenerationJob
		Public Sub Start(ByVal website As String)
			' Create a PDF from any existing web page
			Dim renderer As New ChromePdfRenderer()
			Dim pdf As PdfDocument = renderer.RenderUrlAsPdf(website)
			Dim filePath = AppContext.BaseDirectory & "result.pdf"
			pdf.SaveAs(filePath)
		End Sub
	End Class
End Namespace

IronPDF dispose d'une méthode intégrée pour télécharger un site web à partir d'une URL et l'enregistrer en tant que document PDF. Nous allons utiliser cette méthode dans notre travail pour le télécharger et l'enregistrer dans un emplacement temporaire. Cette tâche d'arrière-plan peut être modifiée pour prendre plusieurs URL de sites web et les enregistrer au format PDF.

Ajoutons maintenant un contrôleur pour exposer les API de génération et de téléchargement de PDF.

using Hangfire;
using HangfireDemo.Core;
using Microsoft.AspNetCore.Mvc;
namespace HangfireDemo.Controllers;
[ApiController]
[Route("[controller]")]
public class PdfGeneratorController : ControllerBase
{
    [HttpGet("request", Name = "Start PDF Generation")]
    public void Start([FromQuery] string websiteUrl)
    {
        BackgroundJob.Enqueue<PdfGenerationJob>(x => x.Start(websiteUrl));
    }
    [HttpGet("result", Name = "Download PDF Generation")]
    public IActionResult WebResult()
    {
        var filePath = AppContext.BaseDirectory + "result.pdf";
        var stream = new FileStream(filePath, FileMode.Open);
       return new FileStreamResult(stream, "application/octet-stream") { FileDownloadName = "website.pdf" };
    }
}

using Hangfire;
using HangfireDemo.Core;
using Microsoft.AspNetCore.Mvc;
namespace HangfireDemo.Controllers;
[ApiController]
[Route("[controller]")]
public class PdfGeneratorController : ControllerBase
{
    [HttpGet("request", Name = "Start PDF Generation")]
    public void Start([FromQuery] string websiteUrl)
    {
        BackgroundJob.Enqueue<PdfGenerationJob>(x => x.Start(websiteUrl));
    }
    [HttpGet("result", Name = "Download PDF Generation")]
    public IActionResult WebResult()
    {
        var filePath = AppContext.BaseDirectory + "result.pdf";
        var stream = new FileStream(filePath, FileMode.Open);
       return new FileStreamResult(stream, "application/octet-stream") { FileDownloadName = "website.pdf" };
    }
}

Imports Hangfire
Imports HangfireDemo.Core
Imports Microsoft.AspNetCore.Mvc
Namespace HangfireDemo.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class PdfGeneratorController
		Inherits ControllerBase

		<HttpGet("request", Name := "Start PDF Generation")>
		Public Sub Start(<FromQuery> ByVal websiteUrl As String)
			BackgroundJob.Enqueue(Of PdfGenerationJob)(Function(x) x.Start(websiteUrl))
		End Sub
		<HttpGet("result", Name := "Download PDF Generation")>
		Public Function WebResult() As IActionResult
			Dim filePath = AppContext.BaseDirectory & "result.pdf"
			Dim stream = New FileStream(filePath, FileMode.Open)
		   Return New FileStreamResult(stream, "application/octet-stream") With {.FileDownloadName = "website.pdf"}
		End Function
	End Class
End Namespace

Ici, nous avons créé deux API, l'une pour lancer la tâche d'arrière-plan afin de prendre l'URL du site web et de lancer le téléchargement. Une autre API consiste à télécharger le résultat au format PDF. Les API se présentent comme suit.

Le résultat ressemble à ce qui suit.

Licence (essai gratuit disponible)

Pour que le code ci-dessus fonctionne sans filigrane, une clé de licence est nécessaire. Une licence d'essai est disponible pour les développeurs après inscription à IronPDF Free Trial. Aucune carte de crédit n'est requise pour une licence d'essai. Vous pouvez indiquer votre adresse électronique et vous inscrire pour un essai gratuit.

Conclusion

Hangfire et IronPDF constituent une combinaison idéale pour générer et télécharger des PDF en arrière-plan. Nous pouvons utiliser Hangfire dans différents paradigmes de programmation pour traiter des tâches de longue durée. IronPDF offre une solution flexible et facile à utiliser pour générer des PDF. Pour en savoir plus sur IronPDF, vous pouvez trouver les documents Documentation IronPDF.

Vous pouvez également explorer d'autres outils de la suite de produits Iron Software qui vous aideront à améliorer vos compétences en programmation et à répondre aux exigences des applications modernes.