
Hangfire .NET Core (Wie es für Entwickler funktioniert)
Die moderne Anwendungsentwicklung erfordert häufig die Bearbeitung von Hintergrundaufgaben, um große Arbeitslasten zu bewältigen. In solchen Szenarien benötigen wir Hintergrundjob-Handler, die in der Lage sind, mehrere Jobs auszuführen. Ein solcher Hintergrundjob-Handler für C# .NET Core-Anwendungen ist Hangfire. In diesem Blog werden wir lernen, wie man Hangfire-Hintergrundjobs verwaltet und wie man sie mit anderen Paketen wie IronPDF for PDF Generation verwendet, um im Hintergrund PDF-Dokumente zu erstellen.
Hangfire vereinfacht die Implementierung von Hintergrundverarbeitung in ASP.NET Core- oder .NET Core 6-Web-API-Anwendungen, indem es einen zuverlässigen und flexiblen Rahmen für die Verwaltung und Ausführung von Hintergrundjobs bietet. Hangfire ist als NuGet-Paket verfügbar und kann mit der .NET-CLI wie unten gezeigt installiert werden:
Implementierung in .NET Core Web API
Um mehr über Hangfire zu erfahren, erstellen wir eine einfache .NET Core-API-Anwendung und installieren Hangfire mit dem CLI.
dotnet new webapi -n HangfireDemo
cd HangfireDemo
dotnet build
dotnet add package Hangfire --version 1.8.6
dotnet build
Hier erstellen wir eine einfache Wetter-REST-API mit .NET CLI. Die erste Zeile erstellt ein .NET Core-Web-API-Projekt namens HangfireDemo, um API-Endpunkte auszuführen. Die zweite Zeile navigiert zu unserem neu erstellten Ordner "HangfireDemo" und dann bauen wir das Projekt. Als Nächstes fügen wir das Hangfire-NuGet-Paket zu unserem Projekt hinzu und bauen es erneut. Danach können Sie Ihr Projekt in jedem Editor Ihrer Wahl öffnen, wie Visual Studio 2022 oder JetBrains Rider. Wenn Sie das Projekt nun ausführen, sehen Sie den Swagger wie folgt:

Hier sehen wir die Wetter-GET-APIs, die Datum, Zusammenfassung und Temperatur zurückgeben.

Nun fügen wir einen Hangfire-Hintergrundjob-Prozessor hinzu. Öffnen Sie das Projekt in Visual Studio.
Hangfire Job Processor hinzufügen
Konfigurieren Sie Hangfire in Ihrer Anwendung, typischerweise in der Startup.cs-Datei. Dies beinhaltet die Einrichtung eines Job-Speichers und die Initialisierung des Hangfire-Servers.
// 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.vb
Imports Hangfire
Public Class Startup
Public Sub ConfigureServices(services As IServiceCollection)
' Add Hangfire services and use SQL Server as storage option
services.AddHangfire(Sub(config) config.UseSqlServerStorage("your_connection_string"))
services.AddHangfireServer()
End Sub
Public Sub Configure(app As IApplicationBuilder, env As IHostingEnvironment)
' Use Hangfire Server and Dashboard for monitoring and managing jobs
app.UseHangfireServer()
app.UseHangfireDashboard()
' Your other configuration settings
End Sub
End ClassDie ConfigureServices-Methode wird verwendet, um Speicher hinzuzufügen, um die neu erstellten Jobs von Hangfire zu speichern. Hier wird eine SQL-Server-Datenbank verwendet. Die SQL Server-Verbindungszeichenfolge sollte durch "your_connection_string" ersetzt werden. Man kann auch den In-Memory-Speicher mit Hangfire.InMemory verwenden.
Und ersetzen durch:
services.AddHangfire(configuration => { configuration.UseInMemoryStorage(); });services.AddHangfire(Sub(configuration)
configuration.UseInMemoryStorage()
End Sub)Hintergrundaufträge erstellen
Definieren Sie die Methoden, die Sie als Hintergrundjobs ausführen möchten. Diese Methoden sollten statische oder Instanzmethoden einer Klasse mit einem parameterlosen Konstruktor sein. Jobs können als wiederkehrende Jobs ausgeführt werden, oder Sie können mehrere Jobs gleichzeitig ausführen.
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 ClassJobs in der Warteschlange
Reihen Sie Hintergrundjobs mit der Hangfire-API ein. Sie können Hintergrundjobs planen, die zu einem bestimmten Zeitpunkt, nach einer Verzögerung oder regelmäßig ausgeführt werden sollen.
// 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)Hangfire Dashboard und Server
Das Hangfire-Dashboard und der Server können in der Configure-Methode für die Echtzeitüberwachung von Jobs hinzugefügt werden.
// Run Hangfire server and dashboard
app.UseHangfireServer();
app.UseHangfireDashboard();' Run Hangfire server and dashboard
app.UseHangfireServer()
app.UseHangfireDashboard()Der Server kann auch in ConfigureServices hinzugefügt werden.
services.AddHangfireServer();services.AddHangfireServer()Jobs feuern und vergessen
// 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 jobWiederkehrende Aufträge
// 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)Aufgeschobene Aufträge
// 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))Fortsetzungen
// 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!"))Batch-Auftrag
// 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)Batch-Fortsetzungsauftrag
// 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)Armaturenbrett
Hangfire Dashboard ist der Ort, an dem Sie alle Informationen über Ihre Hintergrundjobs finden können. Es ist als OWIN Middleware geschrieben (wenn Sie mit OWIN nicht vertraut sind, machen Sie sich keine Sorgen), sodass Sie es in Ihre ASP.NET-, ASP.NET MVC-, Nancy- und ServiceStack-Anwendungen einfügen sowie das OWIN Self-Host-Feature verwenden können, um das Dashboard in Konsolenanwendungen oder Windows-Diensten zu hosten.
Wenn Sie das Dashboard aktiviert haben, ist es unter der /hangfire/-Erweiterung verfügbar. In diesem Dashboard können Sie Hintergrundjobs verwalten, Hintergrundjobs planen und einmalige Jobs sowie wiederkehrende Jobs anzeigen. Die Jobs können mit einer Job-ID identifiziert werden.
Live-Verarbeitung

Erfolgreiche Aufträge
Erfolgreiche Jobs unten anzeigen.

Geplante Aufträge

Wenn Ihre Anwendung ausgeführt wird, kümmert sich Hangfire um die Verarbeitung der Hintergrundjobs basierend auf den konfigurierten Einstellungen.
Denken Sie daran, die Hangfire-Dokumentation für weitere erweiterte Konfigurationsoptionen und Funktionen zu überprüfen: Hangfire Dokumentation und der vollständige Code kann auf GitHub Hangfire Demo gefunden werden.
Einführung in IronPDF
IronPDF for .NET PDF Generation ist ein NuGet-Paket aus Iron Software's PDF Library, das beim Lesen und Erstellen von PDF-Dokumenten hilft. Es kann einfach formatierte Dokumente mit Stilinformationen in PDF konvertieren. IronPDF kann problemlos PDFs aus HTML-Inhalten erstellen. Es kann das HTML von der URL herunterladen und dann PDFs erstellen.
Die Hauptattraktion von IronPDF ist seine HTML-zu-PDF-Konvertierungsfunktion, die Layouts und Stile bewahrt. Es kann PDFs aus Webinhalten erstellen, ideal für Berichte, Rechnungen und Dokumentationen. 
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 ClassErste Schritte mit IronPDF
IronPDF-Bibliothek installieren
Installation mit NuGet Package Manager
Um IronPDF in Ihr Hangfire .NET-Projekt mithilfe des NuGet-Paketmanagers zu integrieren, folgen Sie diesen Schritten:
- Öffnen Sie Visual Studio und klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt.
- Wählen Sie "NuGet-Pakete verwalten…" aus dem Kontextmenü.
- Gehen Sie zur Registerkarte "Durchsuchen" und suchen Sie nach IronPDF.
- Wählen Sie die IronPDF-Bibliothek aus den Suchergebnissen aus und klicken Sie auf die Schaltfläche Installieren.
- Akzeptieren Sie alle Lizenzvereinbarungen.
Wenn Sie die Verwendung der Paket-Manager-Konsole bevorzugen, führen Sie den folgenden Befehl aus:
Dies wird IronPDF in Ihr Projekt herunterladen und installieren.
Installation über NuGet Website
Für einen detaillierten Überblick über IronPDF, einschließlich Funktionen, Kompatibilität und zusätzlicher Downloadoptionen, besuchen Sie die IronPDF-Seite auf der NuGet-Website unter https://www.nuget.org/packages/IronPdf.
Installation über DLL
Alternativ können Sie IronPDF direkt über seine DLL-Datei in Ihr Projekt aufnehmen. Laden Sie die ZIP-Datei herunter, die die DLL von diesem IronPDF-Direktdownload enthält. Entpacken Sie es und nehmen Sie die DLL in Ihr Projekt auf.
Jetzt modifizieren wir unsere Anwendung, um einen Hintergrundverarbeitungsjob hinzuzufügen, der eine Website als PDF-Datei herunterlädt.
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 NamespaceIronPDF verfügt über eine integrierte Methode, um eine Website von einer URL herunterzuladen und als PDF-Dokument zu speichern. Wir werden diese Methode in unserem Job verwenden, um sie herunterzuladen und an einem angegebenen Speicherort zu speichern. Dieser Hintergrundjob kann so geändert werden, dass er mehrere Website-URLs aufnimmt und als PDFs speichert.
Fügen wir nun einen Controller hinzu, um die APIs zur PDF-Erstellung und -Herunterladung bereitzustellen.
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 NamespaceHier haben wir zwei APIs erstellt: Eine, um den Hintergrundjob zu starten und die Website-URL für den Download zu initiieren, und eine andere API, um das resultierende PDF herunterzuladen. Die APIs werden wie unten dargestellt.

Und das Ergebnis sieht so aus:

Lizenzierung (Kostenlose Testversion verfügbar)
Für den obigen Code ist ein Lizenzschlüssel erforderlich, um ohne Wasserzeichen zu arbeiten. Eine Testlizenz ist für Entwickler verfügbar, nachdem sie sich bei IronPDF Free Trial registriert haben. Für eine Testlizenz ist keine Kreditkarte erforderlich. Sie können Ihre E-Mail-ID angeben und sich für eine kostenlose Testversion registrieren.
Abschluss
Hangfire und IronPDF zusammen sind eine großartige Kombination zum Generieren und Herunterladen von PDFs im Hintergrund. Hangfire ermöglicht eine effiziente Verarbeitung von langlaufenden Aufgaben, während IronPDF eine flexible und einfach zu bedienende Lösung für die PDF-Erstellung bietet. Um mehr über IronPDF zu erfahren, können Sie die IronPDF-Dokumentation besuchen.
Entdecken Sie auch andere Tools aus der Iron Software Product Suite, die Ihre Programmierkenntnisse verbessern und modernen Anwendungsanforderungen gerecht werden können.

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
Verwandte Artikel


