Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Async Await
.NET HILFE

C# async await (Wie es für Entwickler funktioniert)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Nutzung asynchroner Programmierung für eine effiziente PDF-Verarbeitung in .NET

In modernen Web- und Serveranwendungen sind Leistung und Skalierbarkeit von größter Bedeutung. Die asynchrone Programmierung in C# mit den async und await Schlüsseln ermöglicht es Entwicklern, nicht blockierende, hochreaktionsfähige Anwendungen zu erstellen. In Kombination mit leistungsstarken Bibliotheken wie IronPDF können Entwickler die Vorteile einer asynchronen Methode voll ausschöpfen, insbesondere bei der Arbeit mit I/O-gebundenen Aufgaben wie der PDF-Erstellung und -Manipulation.

In diesem Artikel werden wir erkunden, wie man asynchronen Code mit IronPDF schreibt, synchrone und asynchrone Programmierung vergleicht und reale Beispiele für Aufgaben wie PDF-Erstellung, Textextraktion und -manipulation bereitstellt. Darüber hinaus behandeln wir Best Practices für den Umgang mit mehreren Aufgaben und demonstrieren, wie man Code schreibt, der sowohl synchrone als auch asynchrone Codes nahtlos integriert.

Einführung in die asynchrone Programmierung

Asynchrone Programmierung in C# ist eine wesentliche Technik, die es Ihren Anwendungen ermöglicht, Aufgaben auszuführen, ohne den Hauptthread zu blockieren. Sie ist besonders nützlich für den Umgang mit langwierigen Operationen wie Datenbankabfragen, Datei-I/O oder der Erstellung oder Manipulation von PDF-Dateien.

IronPDF ist eine robuste Bibliothek, die die PDF-Manipulation in .NET-Anwendungen vereinfacht. Es ermöglicht verschiedene PDF-Operationen, von der Umwandlung von HTML in PDF bis hin zur Extraktion von Text und Bildern. Durch die Integration von IronPDF in asynchrone Programmiermuster können Entwickler die Leistung von Anwendungen, die mit PDFs umgehen, erheblich verbessern.

Async/Await in C# verstehen

Bevor wir darauf eingehen, wie man async/await mit IronPDF verwendet, werfen wir zunächst einen kurzen Blick darauf, was diese Schlüsselwörter bewirken und warum sie in der modernen .NET-Entwicklung wichtig sind.

Was ist Async/Await?

Die Schlüsselwörter async und await werden verwendet, um asynchrone Methoden in C# zu definieren. Eine asynchrone Methode führt eine Operation aus, ohne die Ausführung des Hauptthreads der Anwendung zu blockieren, sodass die Anwendung reaktionsfähig bleibt, selbst wenn sie langwierige Aufgaben ausführt.

  • async: Dieses Schlüsselwort wird auf Methoden angewendet, die asynchrone Operationen ausführen sollen. Es zeigt an, dass die Methode mindestens einen await-Ausdruck enthält.
  • await: Mit diesem Schlüsselwort wird die Ausführung der Methode angehalten, bis die erwartete Aufgabe abgeschlossen ist. Es stellt sicher, dass der Thread frei ist, um andere Aufgaben auszuführen, während auf das Ende der Operation gewartet wird.
public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}
public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}
Public Async Function WaitExampleAsync() As Task
	Await Task.Delay(1000) ' Waits for 1 second without blocking the thread
	Console.WriteLine("Finished waiting asynchronously!")
End Function
$vbLabelText   $csharpLabel

C# Async Await (So funktioniert es für Entwickler): Abbildung 1

Asynchrone Methoden verbessern die Reaktionsfähigkeit, indem sie den Hauptthread freigeben, um andere Operationen zu behandeln, während auf die Beendigung der Aufgaben gewartet wird.

Schlüsselvorteile der asynchronen Programmierung

  • Nicht blockierende Operationen: Bei der asynchronen Programmierung blockieren zeitaufwändige Operationen (wie Datei-E/A oder Netzwerkanfragen) nicht den Hauptthread. Dies ist entscheidend für Webanwendungen, da nicht blockierende Operationen sicherstellen, dass der Server mehrere Anfragen gleichzeitig verarbeiten kann.
  • Verbesserte Skalierbarkeit: Das Schlüsselwort async ermöglicht es der Anwendung, mehr gleichzeitige Operationen mit weniger Threads zu verarbeiten, was die Skalierbarkeit verbessert.
  • Bessere Benutzererfahrung: Bei Desktop- oder Webanwendungen stellen asynchrone Operationen sicher, dass die Benutzeroberfläche auf Benutzereingaben reagiert, während im Hintergrund Aufgaben ausgeführt werden.

Synchroner und asynchroner Code

Zu verstehen, wann man synchrone Programmierung im Vergleich zu asynchroner Programmierung einsetzen sollte, ist entscheidend für ein effizientes Anwendungsdesign.

  • Synchrone Programmierung führt eine Operation nach der anderen aus und blockiert den Hauptthread, bis die Operation abgeschlossen ist. Zum Beispiel könnte eine Methode, die ein PDF mit synchronem Code generiert, so aussehen:
public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}
public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}
Public Sub GeneratePdfSync()
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>")
	pdf.SaveAs("output.pdf")
End Sub
$vbLabelText   $csharpLabel

Während einfach, kann dieser Ansatz Leistungseinbrüche verursachen, insbesondere bei Webanwendungen, die mehrere Aufgaben gleichzeitig verarbeiten, oder in Szenarien, die intensive I/O erfordern.

  • Asynchrone Programmierung ermöglicht Operationen ohne Blockierung des Hauptthreads. Dies ist besonders vorteilhaft für I/O-gebundene Aufgaben wie die PDF-Erstellung, bei denen Sie asynchronen Code verwenden können, um die Anwendung reaktionsfähig zu halten.

Im nächsten Abschnitt werden wir untersuchen, wie asynchrone Programmierung mit IronPDF integriert werden kann, um Ihre PDF-Verarbeitung zu verbessern.

Integration von Async/Await mit IronPDF

IronPDF ist eine leistungsstarke PDF-Manipulationsbibliothek für .NET, die es einfach macht, mit PDF-Dateien zu arbeiten. Sie bietet Funktionen, die es ermöglichen, PDFs zu generieren, zu bearbeiten und Inhalte zu extrahieren, mit minimalem Einrichtungsaufwand und geringem Kodierungsaufwand. In Kombination mit dem async/await-Muster von C# kann IronPDF PDF-bezogene Operationen auf nicht blockierende Weise ausführen und so sowohl die Leistung als auch die Skalierbarkeit von Anwendungen verbessern, die umfangreicher PDF-Verarbeitung erfordern.

IronPDF Überblick

C# Async Await (So funktioniert es für Entwickler): Abbildung 2

IronPDF ermöglicht es .NET-Entwicklern, PDF-Funktionalität direkt in ihre Anwendungen zu integrieren, sei es für Web- oder Desktop-Umgebungen. Hier sind einige der Hauptmerkmale, die IronPDF bietet:

  • HTML-zu-PDF-Konvertierung: IronPDF kann HTML-Inhalte (einschließlich CSS, Bilder und JavaScript) in vollständig formatierte PDFs konvertieren. Dies ist besonders nützlich, um dynamische Webseiten oder Berichte als PDFs zu rendern.
  • PDF-Bearbeitung: Mit IronPDF können Sie bestehende PDF-Dokumente bearbeiten, indem Sie Text, Bilder und Grafiken hinzufügen sowie den Inhalt bestehender Seiten ändern .
  • Text- und Bildextraktion: Die Bibliothek ermöglicht es Ihnen, Text und Bilder aus PDFs zu extrahieren , wodurch das Parsen und Analysieren von PDF-Inhalten vereinfacht wird.
  • Formularausfüllen: IronPDF unterstützt das Ausfüllen von Formularfeldern in PDFs, was für die Erstellung individueller Dokumente nützlich ist.
  • Wasserzeichen: Es ist auch möglich, PDF-Dokumenten Wasserzeichen hinzuzufügen, um Markenrechte zu wahren oder Urheberrechte zu schützen.

Warum IronPDF mit Async/Await verwenden?

Obwohl IronPDF nicht nativ asynchron ist, ist es aufgrund der I/O-gebundenen Natur der meisten PDF-Verarbeitungsvorgänge gut für das async/await-Muster geeignet. Zum Beispiel kann das Umwandeln von HTML in PDF oder das Laden eines großen PDF-Dokuments viel Zeit in Anspruch nehmen, aber dies kann asynchron erfolgen, um zu verhindern, dass der Hauptthread blockiert wird.

Hier sind einige Beispiele dafür, wie IronPDF gut zur asynchronen Programmierung passt:

  • PDF-Generierung: Wenn Ihre Anwendung mehrere PDFs auf Basis dynamischer Inhalte generieren muss, ermöglicht die asynchrone Ausführung dieser Prozesse, dass das System während der PDF-Erstellung reaktionsfähig bleibt.
  • PDF-Bearbeitung: Wenn Sie große PDFs bearbeiten müssen, z. B. Wasserzeichen hinzufügen oder Dokumente zusammenführen, stellt die asynchrone Ausführung dieser Aufgaben sicher, dass Ihre Anwendung nicht hängen bleibt, während diese zeitaufwändigen Operationen im Hintergrund verarbeitet werden.
  • Datei-E/A: Das Lesen und Schreiben von PDFs ist eine E/A-gebundene Operation. Asynchrone Programmierung ist ideal für diese Aufgaben, da sie Systemressourcen freigibt und unnötige Blockierungen vermeidet.

Basisches Beispiel: Asynchrone PDF-Erzeugung mit IronPDF

Hier ein Beispiel, wie man asynchronen Code mit IronPDF schreibt, um eine PDF-Datei zu erzeugen:

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}
using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}
Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Initialize renderer
		Dim renderer As New ChromePdfRenderer()

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"))

		' Save the generated PDF to a file
		Await Task.Run(Function() pdf.SaveAs("output.pdf"))
	End Function
End Class
$vbLabelText   $csharpLabel

C# Async Await (So funktioniert es für Entwickler): Abbildung 3

Wie das funktioniert

  1. Erstellung des HTML-zu-PDF-Konverters:
    Die Klasse ChromePdfRenderer wird verwendet, um HTML-Inhalte in ein PDF umzuwandeln. In diesem Beispiel übergeben wir einfachen HTML-Inhalt als Zeichenkette ("

    Async PDF Example

    "), aber in einer realen Anwendung könnte dies dynamisches HTML sein, wie eine Berichtsvorlage.

  2. Verwendung von Task.Run zur asynchronen PDF-Generierung:
    Die Methode RenderHtmlAsPdf ist nicht standardmäßig asynchron, daher verwenden wir Task.Run(), um die PDF-Generierung in einen Hintergrundthread auszulagern. Das ist wichtig, weil die PDF-Erstellung besonders ressourcenintensiv und zeitaufwändig sein kann, insbesondere bei der Arbeit mit großen oder komplexen Dokumenten.

  3. Speichern der PDF-Datei:
    Nachdem die PDF-Datei generiert wurde, wird sie mit pdf.SaveAs() im Dateisystem gespeichert. Diese E/A-Operation ist außerdem in Task.Run() eingebettet, um sicherzustellen, dass der Hauptthread beim Speichern der Datei nicht blockiert wird.

  4. Warten auf Operationen:
    Das Schlüsselwort await stellt sicher, dass jede asynchrone Operation abgeschlossen ist, bevor die nächste beginnt. Während auf die PDF-Erstellung gewartet wird, bleibt der Hauptthread frei, um andere Aufgaben zu bearbeiten (z. B. das Bedienen anderer HTTP-Anfragen in einer Webanwendung).

Mehrere Aufgaben mit IronPDF bewältigen

Bei Anwendungen, die mit großen PDFs umgehen, müssen Sie möglicherweise mehrere Operationen ausführen, wie das Aufteilen, Zusammenführen oder Hinzufügen von Inhalten in großen Dateien. Die Verwendung von async stellt sicher, dass während eine Operation verarbeitet wird, die Anwendung reaktionsfähig auf Benutzereingaben oder -anfragen bleibt.

Zum Beispiel könnten Sie mehrere asynchrone Operationen in einer Pipeline kombinieren:

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}
using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}
Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim renderer As New ChromePdfRenderer()
		Dim page As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>")

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("output.pdf"))

		' Perform some operations asynchronously
		Await Task.Run(Function() pdf.ApplyWatermark("Confidential"))

		Dim merged As PdfDocument = Await Task.Run(Function() PdfDocument.Merge(pdf, page))
		Await Task.Run(Function() merged.SaveAs("processed_output.pdf"))
	End Function
End Class
$vbLabelText   $csharpLabel

C# Async Await (So funktioniert es für Entwickler): Abbildung 4

In diesem Beispiel laden wir eine PDF-Datei und erstellen eine neue, fügen ein Wasserzeichen hinzu, führen die beiden PDFs zusammen und speichern sie, alles ohne den Hauptthread zu blockieren.

Best Practices für asynchrone Operationen mit IronPDF

  • Überlegungen zum Thread-Pool: Da IronPDF für die Verarbeitung auf Hintergrundthreads angewiesen ist, sollten Sie den Thread-Pool bei der Verwendung von Task.Run() berücksichtigen. Für hochfrequente Aufgaben sollten Sie in Betracht ziehen, einen dedizierten Hintergrunddienst zu verwenden oder Aufgaben zu priorisieren, um den Threadpool nicht zu überlasten.
  • Vermeiden Sie asynchrone void-Methoden: Verwenden Sie immer async Task für Methoden, die asynchrone Operationen durchführen. Reservieren Sie async void Methoden für Ereignishandler.
  • Abbruchtoken: Bei langlaufenden Vorgängen wie der PDF-Generierung oder der Textextraktion ist es ratsam, Abbruchtoken zu unterstützen, damit Benutzer den Vorgang bei Bedarf abbrechen können. Dies stellt sicher, dass Ressourcen freigegeben werden, wenn die Operation nicht mehr benötigt wird.
public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}
public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}
Public Async Function GeneratePdfWithCancellationAsync(ByVal cancellationToken As CancellationToken) As Task
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken)

	If cancellationToken.IsCancellationRequested Then
		Console.WriteLine("Operation was canceled.")
		Return
	End If
	pdf.SaveAs("output.pdf")
End Function
$vbLabelText   $csharpLabel
  • Fehlerbehandlung: Wie bei allen asynchronen Operationen muss eine ordnungsgemäße Fehlerbehandlung für Ausnahmen sichergestellt werden, die während der PDF-Verarbeitung auftreten können, wie z. B. Probleme beim Dateizugriff oder ungültige Eingabedaten.
try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
Try
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"))
	pdf.SaveAs("output.pdf")
Catch ex As Exception
	Console.WriteLine($"Error: {ex.Message}")
End Try
$vbLabelText   $csharpLabel

Abschluss

IronPDF ist eine vielseitige und leistungsstarke PDF-Manipulationsbibliothek, die sich hervorragend mit dem C# async/await-Muster ergänzt. Durch die Nutzung der asynchronen Programmierung mit IronPDF können Sie die Leistung und Skalierbarkeit Ihrer .NET-Anwendungen, die sich mit der Generierung und Manipulation von PDFs befassen, erheblich verbessern. Egal, ob Sie dynamische Berichte generieren, Daten aus Dokumenten extrahieren oder PDFs bearbeiten, die nahtlose Integration von IronPDF mit der asynchronen Programmierung macht es zu einer hervorragenden Wahl für moderne .NET-Entwickler.

Vergessen Sie nicht, die kostenlose Testversion von IronPDF zu erkunden, die Zugriff auf alle Funktionen bietet und es Ihnen ermöglicht, diese Fähigkeiten in Ihren eigenen Projekten zu testen. Durch die Einbeziehung von asynchronen Operationen mit IronPDF werden Sie in der Lage sein, schnellere, effizientere Anwendungen zu erstellen, die mit zunehmenden Arbeitslasten besser skalieren.

Häufig gestellte Fragen

Wie kann ich HTML zu PDF in C# mit asynchroner Programmierung konvertieren?

Sie können die RenderHtmlAsPdf-Methode von IronPDF in Verbindung mit Task.Run verwenden, um die Konvertierung von HTML zu PDF asynchron durchzuführen. Dieser Ansatz stellt sicher, dass der Hauptthread während des PDF-Generierungsprozesses nicht blockiert wird.

Was sind die Vorteile der asynchronen Programmierung in C#?

Asynchrone Programmierung in C# ermöglicht es Anwendungen, Aufgaben auszuführen, ohne den Hauptthread zu blockieren, was die Anwendungsreaktionsfähigkeit und Skalierbarkeit verbessert. Dies ist besonders nützlich bei der Durchführung langwieriger Operationen wie der PDF-Verarbeitung mit Bibliotheken wie IronPDF.

Wie verbessern async und await die Leistung von C#-Anwendungen?

Die Schlüsselwörter async und await erlauben es Anwendungen, reaktionsfähig zu bleiben, indem sie den Hauptthread freigeben, während sie auf den Abschluss langlaufender Operationen warten. Dies verbessert die Leistung und Skalierbarkeit, insbesondere wenn sie mit Bibliotheken wie IronPDF für Aufgaben wie die PDF-Erstellung verwendet werden.

Kann asynchrone Programmierung mit PDF-Bibliotheken verwendet werden?

Ja, asynchrone Programmierung kann effektiv mit PDF-Bibliotheken wie IronPDF integriert werden. Obwohl diese Bibliotheken nicht nativ asynchron sind, ermöglicht Task.Run die Durchführung von PDF-Operationen auf nicht blockierende Weise.

Was sind die Best Practices für die Verwendung von async/await bei der PDF-Verarbeitung in C#?

Best Practices umfassen die Verwendung von Abbruch-Token für lange Operationen, das Vermeiden von async void-Methoden und die Sicherstellung einer ordnungsgemäßen Fehlerbehandlung während der PDF-Verarbeitung mit Bibliotheken wie IronPDF. Dies gewährleistet robuste und reaktionsfähige Anwendungen.

Wie verbessert asynchrone Programmierung die Skalierbarkeit in Webanwendungen?

Asynchrone Programmierung ermöglicht es Webanwendungen, mehr gleichzeitige Operationen mit weniger Threads zu verarbeiten, die Skalierbarkeit zu verbessern, indem Ressourcen effizient verwaltet und Engpässe reduziert werden. Dies ist besonders vorteilhaft für Aufgaben, die die PDF-Verarbeitung mit Bibliotheken wie IronPDF umfassen.

Warum ist asynchrone Programmierung wichtig für moderne Webanwendungen?

Asynchrone Programmierung gewährleistet nicht blockierende Operationen, sodass Webserver mehrere Anfragen gleichzeitig bearbeiten und eine bessere Benutzererfahrung mit reaktionsfähigen Schnittstellen bieten können. Dieser Ansatz ist vorteilhaft für Aufgaben wie die PDF-Erstellung bei der Verwendung von Bibliotheken wie IronPDF.

Was ist ein einfaches Beispiel für die Verwendung von async/await zur PDF-Erzeugung in C#?

Ein einfaches Beispiel beinhaltet die Verwendung von IronPDF, um HTML asynchron in PDF zu konvertieren, indem der PDF-Erzeugungscode in Task.Run gewickelt und await verwendet werden, um das PDF zu speichern, um sicherzustellen, dass die Operation den Hauptthread nicht blockiert.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

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

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an