Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Hangfire .NET Core
.NET AIDE

Hangfire .NET Core (Comment cela fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Le développement d'applications modernes nécessite souvent le traitement de tâches en arrière-plan pour gérer de lourdes charges de travail. Dans de tels scénarios, nous avons besoin de gestionnaires de jobs en arrière-plan capables d'exécuter plusieurs jobs. Un tel gestionnaire de jobs en arrière-plan pour les applications C# .NET Core est Hangfire. Dans ce blog, nous allons apprendre à gérer les jobs en arrière-plan Hangfire et comment les utiliser avec d'autres packages comme IronPDF for PDF Generation pour générer des documents PDF en arrière-plan.

Hangfire simplifie l'implémentation 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 gérer et exécuter des jobs en arrière-plan. Hangfire est disponible sous forme de package NuGet et peut être installé en utilisant l'interface en ligne de commande .NET comme indiqué ci-dessous :

dotnet add package Hangfire --version 1.8.6

Implémentation dans .NET Core Web API

Pour apprendre à utiliser Hangfire, créons une simple application API .NET Core et installons Hangfire en utilisant l'interface en ligne de commande.

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

Ici, nous créons une API REST simple pour la météo en utilisant l'interface en ligne de commande .NET. La première ligne crée un projet API Web .NET Core nommé HangfireDemo pour exécuter les points de terminaison de l'API. La deuxième ligne navigue vers notre dossier nouvellement créé "HangfireDemo", puis nous construisons le projet. Ensuite, nous ajoutons le package NuGet Hangfire à notre projet et le reconstruisons. Après cela, vous pouvez ouvrir votre projet dans un éditeur de votre choix, tel que Visual Studio 2022 ou JetBrains Rider. Maintenant, si vous exécutez le projet, vous pouvez voir le Swagger comme suit :

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 1 - Swagger

Ici, nous pouvons voir les API GET Météo, qui retournent date, résumé et température.

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 2 - API GET Météo

Ajoutons maintenant un processeur de jobs en arrière-plan Hangfire. Ouvrez le projet dans Visual Studio.

Ajouter le processeur de jobs Hangfire

Configurez Hangfire dans votre application, généralement dans le fichier Startup.cs. Cela implique de configurer un stockage de jobs et d'initialiser le serveur Hangfire.

// Startup.cs
using Hangfire;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Hangfire services and use SQL Server as storage option
        services.AddHangfire(config => config.UseSqlServerStorage("your_connection_string"));
        services.AddHangfireServer();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Use Hangfire Server and Dashboard for monitoring and managing jobs
        app.UseHangfireServer();
        app.UseHangfireDashboard();
        // Your other configuration settings
    }
}
// Startup.cs
using Hangfire;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Hangfire services and use SQL Server as storage option
        services.AddHangfire(config => config.UseSqlServerStorage("your_connection_string"));
        services.AddHangfireServer();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Use Hangfire Server and Dashboard for monitoring and managing jobs
        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 and use SQL Server as storage option
		services.AddHangfire(Function(config) config.UseSqlServerStorage("your_connection_string"))
		services.AddHangfireServer()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IHostingEnvironment)
		' Use Hangfire Server and Dashboard for monitoring and managing jobs
		app.UseHangfireServer()
		app.UseHangfireDashboard()
		' Your other configuration settings
	End Sub
End Class
$vbLabelText   $csharpLabel

La méthode ConfigureServices est utilisée pour ajouter le stockage afin de sauvegarder les nouveaux jobs créés par Hangfire. Ici, une base de données SQL Server est utilisée. La chaîne de connexion SQL Server doit être remplacée par "your_connection_string". On peut également 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)
$vbLabelText   $csharpLabel

Créer des jobs en arrière-plan

Définissez les méthodes que vous souhaitez exécuter en tant que jobs en arrière-plan. Ces méthodes doivent être des méthodes statiques ou d'instance d'une classe avec un constructeur sans paramètres. Les jobs peuvent être exécutés comme jobs récurrents, ou vous pouvez exécuter plusieurs jobs simultanément.

public class MyBackgroundJob
{
    public void ProcessJob()
    {
        // Background job logic, can be a recurring job or multiple jobs
        Console.WriteLine("Background job is running...");
    }
}
public class MyBackgroundJob
{
    public void ProcessJob()
    {
        // Background job logic, can be a recurring job or multiple jobs
        Console.WriteLine("Background job is running...");
    }
}
Public Class MyBackgroundJob
	Public Sub ProcessJob()
		' Background job logic, can be a recurring job or multiple jobs
		Console.WriteLine("Background job is running...")
	End Sub
End Class
$vbLabelText   $csharpLabel

Mettre en file d'attente des jobs

Mettez en file d'attente des jobs en arrière-plan en utilisant l'API Hangfire. Vous pouvez planifier des jobs en arrière-plan pour qu'ils s'exécutent à une heure spécifique, après un délai ou régulièrement.

// Enqueue a job to run immediately
BackgroundJob.Enqueue<MyBackgroundJob>(x => x.ProcessJob());

// Schedule a job to run after a 5-minute delay
BackgroundJob.Schedule<MyBackgroundJob>(x => x.ProcessJob(), TimeSpan.FromMinutes(5));

// Schedule a recurring job using a job ID
RecurringJob.AddOrUpdate<MyBackgroundJob>("jobId", x => x.ProcessJob(), Cron.Daily);
// Enqueue a job to run immediately
BackgroundJob.Enqueue<MyBackgroundJob>(x => x.ProcessJob());

// Schedule a job to run after a 5-minute delay
BackgroundJob.Schedule<MyBackgroundJob>(x => x.ProcessJob(), TimeSpan.FromMinutes(5));

// Schedule a recurring job using a job ID
RecurringJob.AddOrUpdate<MyBackgroundJob>("jobId", 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 a 5-minute delay
BackgroundJob.Schedule(Of MyBackgroundJob)(Function(x) x.ProcessJob(), TimeSpan.FromMinutes(5))

' Schedule a recurring job using a job ID
RecurringJob.AddOrUpdate(Of MyBackgroundJob)("jobId", Function(x) x.ProcessJob(), Cron.Daily)
$vbLabelText   $csharpLabel

Tableau de bord et serveur Hangfire

Le tableau de bord et le serveur Hangfire peuvent être ajoutés dans la méthode Configure pour la surveillance en temps réel des jobs.

// Run Hangfire server and dashboard
app.UseHangfireServer();
app.UseHangfireDashboard();
// Run Hangfire server and dashboard
app.UseHangfireServer();
app.UseHangfireDashboard();
' Run Hangfire server and dashboard
app.UseHangfireServer()
app.UseHangfireDashboard()
$vbLabelText   $csharpLabel

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

services.AddHangfireServer();
services.AddHangfireServer();
services.AddHangfireServer()
$vbLabelText   $csharpLabel

Jobs à exécution unique

// Fire and forget jobs are executed only once and almost immediately after creation.
var jobId = BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget!")); // Job ID for 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!")); // Job ID for 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!")) ' Job ID for fire and forget job
$vbLabelText   $csharpLabel

Jobs récurrents

// Recurring jobs fire many times based on a specified CRON schedule.
RecurringJob.AddOrUpdate("myrecurringjob", () => Console.WriteLine("Recurring!"), Cron.Daily);
// Recurring jobs fire many times based on a specified CRON schedule.
RecurringJob.AddOrUpdate("myrecurringjob", () => Console.WriteLine("Recurring!"), Cron.Daily);
' Recurring jobs fire many times based on a specified CRON schedule.
RecurringJob.AddOrUpdate("myrecurringjob", Sub() Console.WriteLine("Recurring!"), Cron.Daily)
$vbLabelText   $csharpLabel

Jobs différés

// Delayed jobs are executed only once but after a specified interval.
var jobId = BackgroundJob.Schedule(() => Console.WriteLine("Delayed!"), TimeSpan.FromDays(7));
// Delayed jobs are executed only once but after a specified interval.
var jobId = BackgroundJob.Schedule(() => Console.WriteLine("Delayed!"), TimeSpan.FromDays(7));
' Delayed jobs are executed only once but after a specified interval.
Dim jobId = BackgroundJob.Schedule(Sub() Console.WriteLine("Delayed!"), TimeSpan.FromDays(7))
$vbLabelText   $csharpLabel

Suites

// Continuation jobs are executed once their parent jobs have completed.
BackgroundJob.ContinueJobWith(jobId, () => Console.WriteLine("Continuation!"));
// Continuation jobs are executed once their parent jobs have completed.
BackgroundJob.ContinueJobWith(jobId, () => Console.WriteLine("Continuation!"));
' Continuation jobs are executed once their parent jobs have completed.
BackgroundJob.ContinueJobWith(jobId, Sub() Console.WriteLine("Continuation!"))
$vbLabelText   $csharpLabel

Job en lots

// Batch is a group of background jobs created atomically and considered as a single entity.
var batchId = BatchJob.StartNew(x =>
{
    x.Enqueue(() => Console.WriteLine("Job 1"));
    x.Enqueue(() => Console.WriteLine("Job 2"));
});
// Batch is a group of background jobs created atomically and considered as a single entity.
var batchId = BatchJob.StartNew(x =>
{
    x.Enqueue(() => Console.WriteLine("Job 1"));
    x.Enqueue(() => Console.WriteLine("Job 2"));
});
' Batch is a group of background jobs created atomically and considered as a single entity.
Dim batchId = BatchJob.StartNew(Sub(x)
	x.Enqueue(Sub() Console.WriteLine("Job 1"))
	x.Enqueue(Sub() Console.WriteLine("Job 2"))
End Sub)
$vbLabelText   $csharpLabel

Suite de jobs en lots

// 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"));
});
' Batch continuation is fired when all background jobs in a parent batch are finished.
BatchJob.ContinueBatchWith(batchId, Sub(x)
	x.Enqueue(Sub() Console.WriteLine("Last Job"))
End Sub)
$vbLabelText   $csharpLabel

Tableau de bord

Le tableau de bord Hangfire est l'endroit où vous pouvez trouver toutes les informations sur vos jobs en arrière-plan. Il 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 vos applications ASP.NET, ASP.NET MVC, Nancy et ServiceStack, ainsi qu'utiliser la fonctionnalité OWIN Self-Host pour héberger le tableau de bord à l'intérieur d'applications Console ou de services Windows.

Lorsque vous avez le tableau de bord activé, il est disponible à l'extension /hangfire/. Dans ce tableau de bord, vous pouvez gérer les jobs exécutés en arrière-plan, planifier des jobs en arrière-plan et visualiser les jobs à exécution unique ainsi que les jobs récurrents. Les jobs peuvent être identifiés à l'aide d'un identifiant de job.

Traitement en direct

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 3 - Traitement en direct des jobs

Jobs réussis

Voir les jobs réussis ci-dessous.

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 4 - Jobs réussis

Jobs planifiés

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 5 - Jobs planifiés

Lorsque votre application s'exécute, Hangfire s'occupe de traiter les jobs en arrière-plan en fonction des paramètres configurés.

Remember to check the Hangfire documentation for more advanced configuration options and features: Hangfire Documentation and complete code can be found on GitHub Hangfire Demo.

Introducing IronPDF

IronPDF for .NET PDF Generation is a NuGet package from bibliothèque PDF Iron Software qui aide à lire et générer des documents PDF. Il peut convertir facilement des documents formatés avec des informations de style en PDF. IronPDF peut facilement générer des PDF à partir de contenu HTML. Il peut télécharger le HTML depuis l'URL et ensuite générer 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 contenu web, idéal pour les rapports, les factures et la documentation. Cette fonctionnalité prend en charge la conversion 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();

        // 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");

        // 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");

        // 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();

        // 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");

        // 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");

        // 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()

		' 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")

		' 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")

		' 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
$vbLabelText   $csharpLabel

Commencer avec IronPDF

Installer la bibliothèque IronPDF

Installer en utilisant le Gestionnaire de Packages NuGet

Pour intégrer IronPDF dans votre projet Hangfire .NET en utilisant le gestionnaire de packages NuGet, suivez ces étapes :

  1. Ouvrez Visual Studio et dans l'Explorateur de solutions, faites un clic droit sur votre projet.
  2. Choisissez “Gérer les packages NuGet...” dans le menu contextuel.
  3. Accédez à l'onglet Parcourir et recherchez IronPDF.
  4. Sélectionnez la bibliothèque IronPDF dans les résultats de recherche et cliquez sur le bouton Installer.
  5. Acceptez tout accord de licence s'il y en a.

Si vous préférez utiliser la console du gestionnaire de packages, exécutez la commande suivante :

Install-Package IronPdf

Cela va récupérer et installer IronPDF dans votre projet.

Installer en utilisant le site NuGet

Pour un aperçu détaillé d'IronPDF, y compris les fonctionnalités, la compatibilité et les options de téléchargement supplémentaires, visitez la page IronPDF sur le site NuGet à https://www.nuget.org/packages/IronPdf.

Installer via DLL

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

Maintenant modifions notre application pour ajouter un job de traitement en arrière-plan pour télécharger un site web 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
$vbLabelText   $csharpLabel

IronPDF dispose d'une méthode intégrée pour télécharger un site web à partir d'une URL et l'enregistrer sous forme de document PDF. Nous allons utiliser cette méthode dans notre job pour télécharger et sauvegarder à un emplacement spécifié. Ce job en arrière-plan peut être modifié pour prendre plusieurs URL de sites web et les sauvegarder sous forme de 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
$vbLabelText   $csharpLabel

Ici, nous avons créé deux API : une pour démarrer le job en arrière-plan et prendre l'URL du site web pour initier le téléchargement, et une autre API pour télécharger le PDF résultant. Les API sont représentées comme suit.

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 7 - API de générateur de PDF

Et le résultat ressemble à ceci :

Hangfire .NET Core (Comment ça fonctionne pour le développeur) : Figure 8 - Résultat

Licence (essai gratuit disponible)

Pour que le code ci-dessus fonctionne sans filigranes, une clé de licence est requise. Une licence d'essai est disponible pour les développeurs en s'inscrivant à IronPDF Free Trial. Aucune carte de crédit n'est requise pour une licence d'essai. Vous pouvez fournir votre adresse e-mail et vous inscrire pour un essai gratuit.

Conclusion

Hangfire et IronPDF sont une excellente combinaison pour générer et télécharger des PDF en arrière-plan. Hangfire permet un traitement efficace des tâches de longue durée, tandis qu'IronPDF fournit une solution flexible et facile à utiliser pour la génération de PDF. Pour en savoir plus sur IronPDF, vous pouvez visiter la documentation IronPDF.

Explorez également d'autres outils de la suite de produits Iron Software qui peuvent améliorer vos compétences en programmation et satisfaire aux exigences modernes des applications.

Questions Fréquemment Posées

Qu'est-ce que Hangfire dans .NET Core ?

Hangfire est un framework qui simplifie la mise en œuvre du traitement en arrière-plan dans les applications ASP.NET Core ou .NET Core 6. Il propose une solution fiable et flexible pour gérer et exécuter des travaux en arrière-plan.

Comment installer Hangfire dans une application .NET Core ?

Hangfire peut être installé en tant que package NuGet. Vous pouvez l'ajouter à l'aide de la CLI .NET avec la commande : dotnet add package Hangfire --version 1.8.6.

Quels sont les types de travaux en arrière-plan pris en charge par Hangfire ?

Hangfire prend en charge divers types de travaux en arrière-plan, notamment les travaux à lancer et oublier, les travaux différés, les travaux récurrents et les travaux de continuation.

Comment configurer Hangfire dans une application .NET Core ?

Hangfire est configuré dans le fichier Startup.cs où vous configurez le stockage des travaux et initialisez le serveur Hangfire. Cela implique généralement l'ajout des services Hangfire et la configuration d'un serveur SQL ou d'un stockage en mémoire.

Qu'est-ce que le tableau de bord Hangfire ?

Le tableau de bord Hangfire est un outil pour surveiller et gérer les travaux en arrière-plan. Il fournit des informations sur le traitement en direct, les travaux réussis et les travaux planifiés, et est accessible via une interface Web.

Comment pouvez-vous créer un travail en arrière-plan en utilisant Hangfire ?

Les travaux en arrière-plan peuvent être créés en utilisant Hangfire en définissant les méthodes que vous souhaitez exécuter en tant que travaux et en les mettant en file d'attente à l'aide de l'API Hangfire. Les travaux peuvent être planifiés pour s'exécuter immédiatement, après un délai, ou de manière récurrente.

Comment effectuer des tâches de génération de PDF en arrière-plan avec .NET Core ?

Vous pouvez effectuer des tâches de génération de PDF en arrière-plan en utilisant une bibliothèque PDF qui prend en charge la conversion HTML en PDF. Cela peut être intégré à un cadre de traitement en arrière-plan comme Hangfire pour automatiser la création de PDF à partir de contenu HTML.

Quelles sont les capacités d'une bibliothèque de génération de PDF en .NET ?

Une bibliothèque de génération de PDF peut convertir des chaînes HTML, des fichiers HTML et des URL en PDF. Elle préserve les mises en page et les styles et est utile pour générer des rapports, factures et documentations à partir de contenu Web.

Comment installer une bibliothèque de génération de PDF dans un projet .NET ?

Une bibliothèque de génération de PDF peut être installée en utilisant le gestionnaire de packages NuGet dans Visual Studio ou via la console du gestionnaire de packages avec une commande spécifique. Elle peut également être installée en téléchargeant directement la DLL depuis le site Web de la bibliothèque.

Que faut-il pour utiliser une bibliothèque de génération de PDF sans filigranes ?

Pour utiliser une bibliothèque de génération de PDF sans filigranes, une clé de licence est généralement requise. Une licence d'essai gratuite peut être disponible après inscription sur le site Web de la bibliothèque.

Comment intégrer un outil de génération de PDF avec Hangfire dans .NET Core ?

Vous pouvez intégrer un outil de génération de PDF avec Hangfire dans .NET Core en configurant un travail en arrière-plan qui utilise la bibliothèque de génération de PDF pour convertir HTML en PDF. Cela permet la création et la gestion automatisées de documents dans les applications.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit