Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Async Await Anleitung
.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, hoch reaktionsfä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, von denen erwartet wird, dass sie asynchrone Operationen ausführen. Es zeigt an, dass die Methode mindestens einen await-Ausdruck enthält.
  • await: Dieses Schlüsselwort wird verwendet, um die Ausführung der Methode anzuhalten, 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 (Wie es für Entwickler funktioniert): 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: Mit asynchroner Programmierung blockieren zeitaufwändige Operationen (wie Datei-I/O oder Netzwerk-Anfragen) 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 async-Schlüsselwort ermöglicht es der Anwendung, mehr gleichzeitige Operationen mit weniger Threads zu verarbeiten und verbessert die Skalierbarkeit.
  • Bessere Benutzererfahrung: Für Desktop- oder Webanwendungen sorgen asynchrone Operationen dafür, dass die Benutzeroberfläche reaktionsfähig auf Benutzereingaben bleibt, während Aufgaben im Hintergrund 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 (Wie es für Entwickler funktioniert): 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 umwandeln. Dies ist besonders nützlich, um dynamische Webseiten oder Berichte als PDFs zu rendern.
  • PDF-Bearbeitung: Mit IronPDF können Sie bestehende PDF-Dokumente manipulieren, indem Sie Text, Bilder und Grafiken hinzufügen sowie den Inhalt bestehender Seiten bearbeiten.
  • Text- und Bildextraktion: Die Bibliothek ermöglicht es Ihnen, Text und Bilder aus PDFs zu extrahieren und so einfach PDF-Inhalte zu analysieren und zu verarbeiten.
  • Formularfüllung: IronPDF unterstützt das Ausfüllen von Formularfeldern in PDFs, was nützlich ist, um maßgeschneiderte Dokumente zu erstellen.
  • Wasserzeichen: Es ist auch möglich, Wasserzeichen zu PDF-Dokumenten hinzuzufügen, um Branding oder Urheberrechtsschutz zu bieten.

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-Erstellung: Wenn Ihre Anwendung mehrere PDFs basierend auf dynamischen Inhalten generieren muss, erlaubt das Ausführen dieser Prozesse asynchron, dass das System reaktionsfähig bleibt, während PDFs erstellt werden.
  • PDF-Manipulation: Wenn Sie große PDFs bearbeiten müssen, wie das Hinzufügen von Wasserzeichen oder das Zusammenführen von Dokumenten, stellt das Ausführen dieser Aufgaben asynchron sicher, dass Ihre Anwendung nicht hängt, während diese zeitintensiven Operationen im Hintergrund verarbeitet werden.
  • Datei-I/O: Das Lesen und Schreiben von PDFs ist eine I/O-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 (Wie es für Entwickler funktioniert): Abbildung 3

Wie das funktioniert

  1. Erstellen des HTML zu PDF Konverters:
    Die ChromePdfRenderer-Klasse wird verwendet, um HTML-Inhalte in ein PDF umzuwandeln. In this example, we pass simple HTML content as a string ("

    Async PDF Example

    "), but in a real application, this could be dynamic HTML, such as a report template.

  2. Verwendung von Task.Run für asynchrone PDF-Erstellung:
    Die RenderHtmlAsPdf-Methode ist standardmäßig nicht asynchron, also verwenden wir Task.Run(), um die PDF-Erstellung 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 des PDFs:
    Nachdem das PDF erstellt wurde, wird es mit pdf.SaveAs() im Dateisystem gespeichert. Diese I/O-Operation wird ebenfalls in ein Task.Run() eingebunden, um sicherzustellen, dass sie den Hauptthread beim Speichern der Datei nicht blockiert.

  4. Erwarten von Operationen:
    Das await-Schlüsselwort stellt sicher, dass jede asynchrone Operation abgeschlossen wird, 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 (Wie es für Entwickler funktioniert): 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

  • Threadpool-Überlegungen: Da IronPDF auf Hintergrundthreads zur Verarbeitung angewiesen ist, sollten Sie den Threadpool im Auge behalten, wenn Sie Task.Run() verwenden. 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 von async void Methoden: Verwenden Sie immer async Task für Methoden, die asynchrone Operationen ausführen. Reservieren Sie async void Methoden für Ereignishandler.
  • Abbruch-Token: Für langwierige Operationen wie PDF-Erstellung oder Textextraktion ist es ratsam, Abbruch-Token zu unterstützen, um Benutzern zu ermöglichen, die Operation bei Bedarf abzubrechen. 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 sollten Sie für Ausnahmen, die während der PDF-Verarbeitung auftreten können, wie Datei-Zugriffsprobleme oder ungültige Eingabedaten, eine ordnungsgemäße Fehlerbehandlung sicherstellen.
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?

Du kannst 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 stellt sicher, dass nicht blockierende Operationen möglich sind, 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 führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

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