Moderne Anwendungsentwicklung erfordert oft die Verarbeitung von Hintergrundaufgaben, um große Aufgaben zu bewältigen. In diesem Szenario benötigen wir Hintergrundjob-Handler, um mehrere Aufträge auszuführen. Es gibt viele Job-Handler, und ein solcher Hintergrund-Job-Handler für C# .NET Core-Anwendungen ist Hangfire. In diesem Blog werden wir den Hangfire-Hintergrundjob kennenlernen und wie man ihn mit anderen Paketen wie IronPDF for PDF Generation verwendet, um PDF-Dokumente im Hintergrund zu generieren.

Einführung

Hangfire vereinfacht die Implementierung von Hintergrundverarbeitung in ASP.NET Core oder .NET Core 6 Web-API-Anwendungen, indem es ein zuverlässiges und flexibles Framework zur Verwaltung und Ausführung von Hintergrundjobs bereitstellt. Hangfire ist als NuGet-Paket verfügbar und kann wie unten beschrieben mit dem .NET CLI installiert werden.

dotnet add package Hangfire --version 1.8.6

Implementierung in .NET Core Web API

Um Hangfire kennenzulernen, erstellen wir eine einfache .NET Core API-Anwendung und installieren Hangfire mithilfe von 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 Core Web API-Projekt namens HangfireDemo (auch ASP.NET Core kann erstellt werden), um API-Endpunkte auszuführen. Die zweite Zeile besteht darin, zu unserem neu erstellten Ordner "HangfireDemo" zu navigieren und dann das Projekt zu erstellen. Als nächstes fügten wir das Hangfire NuGet-Paket zu unserem Projekt hinzu und erstellten es erneut. Danach können Sie Ihr Projekt in einem beliebigen Editor Ihrer Wahl, Visual Studio 2022 oder JetBrains Rider öffnen. Wenn Sie nun das Projekt ausführen, sehen Sie den Swagger wie unten dargestellt.

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

Nun wollen wir einen Hangfire-Hintergrundprozessor hinzufügen. Öffnen Sie das Projekt in Visual Studio.

Hangfire Job Processor hinzufügen

Konfigurieren Sie Hangfire in Ihrer Anwendung, normalerweise in der Datei Startup.cs. Dazu gehört das Einrichten eines Jobspeichers und die Initialisierung des Hangfire-Servers.

// 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 wird verwendet, um Speicherplatz zum Speichern der neu erstellten Hangfire-Jobs hinzuzufügen. Hier wird die Datenbank SQL Server verwendet. Die SQL Server-Verbindungszeichenfolge sollte durch "your_connection_string" ersetzt werden. Man kann auch In-Memory-Speicher mit Hangfire.InMemory verwenden.

dotnet add package Hangfire.InMemory --version 0.6.0

Und ersetzen durch

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

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

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

Hintergrundaufträge erstellen

Definieren Sie die Methoden, die Sie im Hintergrund ausführen wollen. Diese Methoden sollten statisch oder Instanzmethoden einer Klasse mit einem parameterlosen Konstruktor sein. Die Aufträge können als wiederkehrende Aufträge ausgeführt werden oder es können mehrere Aufträge ausgeführt werden.

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

Enqueue Jobs

Stellen Sie Hintergrundaufträge mit der Hangfire-API ein. Sie können Hintergrundaufträge so planen, dass sie zu einem bestimmten Zeitpunkt, nach einer Verzögerung oder regelmäßig ausgeführt werden.

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

Hangfire Dashboard und Server

Das Hangfire Dashboard und der Server können mit der Methode Configure hinzugefügt werden.

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

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

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

Der Server kann auch in ConfigureServices hinzugefügt werden.

services.AddHangfireServer();

services.AddHangfireServer();

services.AddHangfireServer()

Fire and Forget Jobs

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

Wiederkehrende Jobs

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

Verspätete Jobs

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

Fortsetzungen

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

Stapelverarbeitungsauftrag

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

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, 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)

Dashboard

Im Hangfire Dashboard finden Sie alle Informationen über Ihre Hintergrundaufträge. Es ist als ein OWIN-Middleware geschrieben (falls Sie mit OWIN nicht vertraut sind, machen Sie sich keine Sorgen), sodass Sie es in Ihre ASP.NET-, ASP.NET MVC-, Nancy- und ServiceStack-Anwendung einfügen sowie die OWIN Self-Host-Funktion verwenden können, um das Dashboard in Konsolenanwendungen oder in Windows-Diensten zu hosten.

Wenn das Dashboard in Ihrer Ansicht aktiviert ist, befindet sich das Dashboard unter der Erweiterung /hangfire/. In diesem Dashboard können Sie im Hintergrund laufende Aufträge verwalten, Hintergrundaufträge planen, "Fire and Forget"-Aufträge und wiederkehrende Aufträge anzeigen. Die Aufträge können anhand der Auftrags-ID identifiziert werden.

Live-Verarbeitung

Erfolglose Jobs

Die erfolgreichen Bewerbungen können unten eingesehen werden.

Geplante Aufträge

Wenn Ihre Anwendung nun läuft, kümmert sich Hangfire um die Verarbeitung der Hintergrundaufträge gemäß den konfigurierten Einstellungen.

Denk daran, die Hangfire-Dokumentation für erweiterte Konfigurationsoptionen und Funktionen zu überprüfen: Hangfire Dokumentation und der vollständige Code ist auf GitHub Hangfire Demo zu finden.

Einführung in IronPDF

IronPDF for .NET PDF-Erstellung ist ein NuGet-Paket aus der PDF-Bibliothek von Iron Software, das beim Lesen und Erstellen von PDF-Dokumenten hilft. Es kann leicht formatierte Dokumente mit Stilinformationen in PDF umwandeln. IronPDF kann problemlos PDFs aus HTML-Inhalten erzeugen. Es kann den HTML-Code von der URL herunterladen und dann PDF-Dateien erzeugen.

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 Dokumentation. Diese Funktion unterstützt die Umwandlung von HTML-Dateien, URLs und HTML-Strings in PDFs.

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

Erste Schritte mit IronPDF

Beginnen Sie noch heute mit der Verwendung von IronPDF in Ihrem Projekt mit einer kostenlosen Testversion.

Erster Schritt:

Kostenloser Start

IronPDF-Bibliothek installieren

Installation mit NuGet-Paketmanager

Gehen Sie folgendermaßen vor, um IronPDF mit Hilfe des NuGet-Paketmanagers in Ihr Hangfire .NET-Projekt zu integrieren:

1. Öffnen Sie Visual Studio und klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt.

2. Wählen Sie "NuGet-Pakete verwalten..." aus dem Kontextmenü.

3. Gehen Sie auf die Registerkarte Durchsuchen und suchen Sie nach IronPDF.

4. Wählen Sie die IronPDF-Bibliothek aus den Suchergebnissen aus und klicken Sie auf die Schaltfläche Installieren.

5. Akzeptieren Sie die Aufforderung zu einer Lizenzvereinbarung.

   Wenn Sie IronPDF über die Paketmanager-Konsole in Ihr Projekt einbinden möchten, führen Sie den folgenden Befehl in der Paketmanager-Konsole aus:

Install-Package IronPdf

Es wird IronPDF in Ihr Projekt holen und installieren.

Installation über die NuGet-Website

Einen detaillierten Überblick über IronPDF, einschließlich seiner Funktionen, Kompatibilität und zusätzlicher Download-Optionen, finden Sie auf der IronPDF-Seite auf der NuGet-Website unter https://www.nuget.org/packages/IronPdf.

Installation über DLL

Alternativ können Sie IronPDF direkt in Ihr Projekt einbinden, indem Sie die DLL-Datei verwenden. Laden Sie die ZIP-Datei mit der DLL hier herunter: IronPDF Direct Download. Entpacken Sie die Datei, und binden Sie die DLL in Ihr Projekt ein.

Ändern wir nun unsere Anwendung, um einen Hintergrundverarbeitungsauftrag zum Herunterladen einer HTTP-Request-Pipeline-Website als PDF-Datei hinzuzufügen.

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 verfügt über eine eingebaute Methode, um eine Website von einer URL herunterzuladen und als PDF-Dokument zu speichern. Wir werden diese Methode in unserem Auftrag verwenden, um sie herunterzuladen und an einem temporären Ort zu speichern. Dieser Hintergrundauftrag kann so modifiziert werden, dass er mehrere Website-URLs aufnimmt und als PDF-Dateien speichert.

Fügen wir nun einen Controller hinzu, um die APIs für die PDF-Erzeugung und den Download 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" };
    }
}

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

Hier haben wir zwei APIs erstellt, eine zum Starten des Hintergrundjobs, um die Website-URL zu übernehmen und den Download zu initiieren. Eine andere API ermöglicht das Herunterladen des PDF-Ergebnisses. Die APIs sehen wie unten dargestellt aus.

Das Ergebnis sieht wie folgt aus.

Lizenzierung (kostenlose Testversion verfügbar)

Damit der obige Code ohne Wasserzeichen funktioniert, ist ein Lizenzschlüssel erforderlich. Eine Testlizenz ist für Entwickler verfügbar, nachdem sie sich für die 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.

Schlussfolgerung

Hangfire und IronPDF zusammen sind eine großartige Kombination, um PDFs im Hintergrund zu generieren und herunterzuladen. Wir können Hangfire in verschiedenen Programmierparadigmen verwenden, um langlaufende Aufgaben zu verarbeiten. IronPDF bietet eine flexible und benutzerfreundliche Lösung zur Erstellung von PDFs. Um mehr über IronPDF zu erfahren, finden Sie die Dokumente in der IronPDF-Dokumentation.

Außerdem können Sie andere Tools aus der Iron Software Product Suite erkunden, die Ihnen helfen, Ihre Programmierfähigkeiten zu verbessern und moderne Anwendungsanforderungen zu erfüllen.