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 de ces gestionnaires de tâches parentales en arrière-plan pour les applications C# .NET Core est Hangfire. Dans ce blog, nous allons découvrir le job d'arrière-plan Hangfire et comment l'utiliser avec d'autres packages tels queIronPDF pour la génération de PDF pour générer des documents PDF en arrière-plan.

Introduction

Feu de paille 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 d'arrière-plan. Hangfire est disponible en tant queNuGet et peut être installé à l'aide de la CLI .NET comme indiqué 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 des applications ASP.NET Core) pour exécuter les points de terminaison de l'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. Il s'agit d'un logiciel intermédiaire OWIN(si vous ne connaissez pas OWIN, ne vous inquiétez pas)afin que vous puissiez l'intégrer à votre application ASP.NET, ASP.NET MVC, Nancy et ServiceStack, et utiliser la fonctionOWIN Self-Host pour héberger le tableau de bord dans les applications de la console ou dans les services Windows.

Lorsque le tableau de bord est activé dans votre vue, il se trouve dans 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 Hangfire pour des options de configuration et des fonctionnalités plus avancées : HangfireDocumentation et le code complet peut être trouvé surDémonstration de GitHub Hangfire.

Présentation d'IronPDF

IronPDF for .NET PDF Generation (en anglais) est unNuGet paquet deBibliothèque PDF d'Iron Software qui permet de lire et de 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.

Le principal attrait d'IronPDF est sonConversion de 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

Vous pouvez également incorporer IronPDF directement dans votre projet à l'aide de son fichier DLL. Téléchargez le fichier ZIP contenant la DLL à partir de ce lienIronPDF Téléchargement direct. 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 qui s'inscrivent auprès deEssai gratuit d'IronPDF. 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 consulter les documents suivantsDocumentation IronPDF.

Vous pouvez également explorer d'autres outils deIron Software Product Suite qui vous aidera à améliorer vos compétences en matière de codage et à répondre aux exigences des applications modernes.