C# ConfigureAwait (Wie es für Entwickler funktioniert)

Als Entwickler kann die asynchrone Programmierung äußerst vorteilhaft sein, da sie die Leistung, Effizienz und Reaktionsfähigkeit Ihrer Anwendungen verbessern kann, insbesondere bei Vorgängen, die eine unvorhersehbare Zeitspanne in Anspruch nehmen können. Durch die Verwendung von `ConfigureAwait(false)` können Sie Deadlocks in bestimmten Szenarien vermeiden. Deadlocks treten in der asynchronen Programmierung auf, wenn ein Synchronisierungskontext (wie ein UI-Thread in einer Desktop-Anwendung) erwartet, dass eine Operation abgeschlossen wird, bevor sie fortfährt. Dennoch wartet die erwartete Aufgabe darauf, dass der Synchronisierungskontext verfügbar ist, was zu einer Warteschleife führt.

Heute werden wir untersuchen, wie ConfigureAwait mit IronPDF verwendet werden kann, um PDF-Verarbeitungsaufgaben effizient durch asynchrones Programmieren auszuführen. IronPDF ist eine .NET-PDF-Bibliothek, die die Arbeit mit PDF-bezogenen Aufgaben zu einem Kinderspiel macht. Mit einem robusten Funktionsumfang, einer starken plattformübergreifenden Kompatibilität und einer umfangreichen Dokumentation ist es ein leistungsstarkes PDF-Werkzeug, das Sie in Ihrem Entwickler-Toolkit haben sollten.

Asynchrone Programmierung in C# verstehen;

Was ist asynchrone Programmierung?

Asynchrone Programmierung bezieht sich auf eine Methode zum Schreiben von Code, bei der bestimmte Vorgänge unabhängig vom Hauptanwendungs-Thread ausgeführt werden können. Dies ist nützlich für langwierige Aufgaben, die Wartezeiten erfordern, wie z. B. E/A-Operationen. Indem diese Aufgaben ausgeführt werden können, ohne den Haupt-Thread zu blockieren, kann die Anwendung weiterlaufen, während diese Aufgaben Zeit benötigen, um abgeschlossen zu werden, was letztendlich die Leistung und Reaktionsfähigkeit der Anwendung verbessert.

Die Rolle von ConfigureAwait in asynchronem Code

ConfigureAwait ist eine Methode in der asynchronen Programmierung, die verwendet wird, um zu steuern, wie eine Fortführung ausgeführt wird. Die Fortsetzung ist der Code, der nach einem await-Ausdruck ausgeführt wird. Standardmäßig erfasst `await` den aktuellen Kontext und versucht, die Fortsetzung zurück in diesen Kontext zu verlagern, was ineffektiv sein kann. ConfigureAwait ermöglicht es, anzugeben, ob die Fortsetzung im erfassten Kontext ausgeführt werden soll, was mit `ConfigureAwait(true)` angegeben wird, oder nicht, was durch `ConfigureAwait(false)` gekennzeichnet ist.

Die Verwendung von **ConfigureAwait(false)** hilft, Deadlocks zu vermeiden, da Sie damit der Aufgabe mitteilen, den aktuellen Synchronisationskontext nicht zu erfassen und nicht zu versuchen, im ursprünglichen Kontext fortzufahren. Dadurch kann die Fortsetzung in einem Thread-Pool-Thread anstelle des ursprünglichen Kontexts ausgeführt werden, wodurch verhindert wird, dass der Haupt-Thread blockiert wird.

`ConfigureAwait(false)` ist besonders nützlich in Bibliothekscode oder in Fällen, in denen das Wiederaufnehmen des ursprünglichen Kontexts unnötig ist, und sorgt so dafür, dass der Code flexibel und frei von Deadlocks bleibt.

So verwenden Sie ConfigureAwait mit IronPDF

Einrichten von IronPDF in Ihrem .NET-Projekt

Um IronPDF in Ihren .NET-Projekten zu verwenden, beginnen Sie mit der Installation des IronPDF NuGet-Pakets. Navigieren Sie dazu zu tools > NuGet Package Manager > NuGet Package Manager for Solution und suchen Sie IronPDF:

Oder führen Sie alternativ den folgenden Befehl in der Paketmanager-Konsole aus:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Um IronPDF in Ihrem Code zu verwenden, stellen Sie sicher, dass Sie die Anweisung `using IronPdf` am Anfang Ihrer Code-Datei platziert haben. Für eine ausführlichere Anleitung zur Einrichtung von IronPDF in Ihrer Umgebung, besuchen Sie die Seite für den Einstieg.

Asynchrone PDF-Erzeugung mit IronPDF

Die asynchrone Generierung von PDF-Dateien kann besonders in Situationen von Vorteil sein, in denen Sie große Mengen an PDF-Dateien generieren oder mehrere Vorgänge gleichzeitig durchführen möchten. Mit IronPDF können Sie PDF-bezogene Aufgaben asynchron ausführen, was etwa wie der folgende asynchrone Code aussehen könnte:

using IronPdf;
using System.Threading.Tasks;
class program
{
    static async Task Main(string[] args)
    {
        await GeneratePdfAsync();
    }
    static async Task GeneratePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        string htmlContent = "<h1>Hello World!</h1>";
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
        await Task.Run(() => pdf.SaveAs("outputAsync.pdf"));
        Console.WriteLine("Working!");
    }
}

using IronPdf;
using System.Threading.Tasks;
class program
{
    static async Task Main(string[] args)
    {
        await GeneratePdfAsync();
    }
    static async Task GeneratePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        string htmlContent = "<h1>Hello World!</h1>";
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
        await Task.Run(() => pdf.SaveAs("outputAsync.pdf"));
        Console.WriteLine("Working!");
    }
}

Imports IronPdf
Imports System.Threading.Tasks
Friend Class program
	Shared Async Function Main(ByVal args() As String) As Task
		Await GeneratePdfAsync()
	End Function
	Private Shared Async Function GeneratePdfAsync() As Task
		Dim renderer As New ChromePdfRenderer()
		Dim htmlContent As String = "<h1>Hello World!</h1>"
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync(htmlContent)
		Await Task.Run(Function() pdf.SaveAs("outputAsync.pdf"))
		Console.WriteLine("Working!")
	End Function
End Class

In diesem Code haben wir ein PDF-Dokument asynchron in der Methode GeneratePdfAsync() erstellt. ChromePdfRenderer wird verwendet, um den Renderer zu erstellen, der entscheidend für die Erstellung einer PDF-Datei aus dem HTML-Inhalt ist. Die PdfDocument-Klasse wird verwendet, um ein PDF aus dem bereitgestellten HTML-String zu erstellen. Sie können sie jedoch auch verwenden, um das PDF aus einer HTML-Datei, einer URL, einem Bild und mehr zu erstellen. Für weitere Informationen zu den verschiedenen Methoden zur Erstellung eines PDF mit IronPDF, schauen Sie sich den Anleitungsbereich zur Erstellung von PDFs an.

Asynchrones Arbeiten mit großen PDF-Dateien

Beim Umgang mit großen PDF-Dateien können asynchrone Methoden mit `ConfigureAwait(false)` die Leistung erheblich verbessern, indem sie den Hauptthread während langwieriger Operationen entlasten. Für dieses Beispiel habe ich ein großes PDF-Dokument genommen und eine Textextraktion durchgeführt, um zu demonstrieren, wie vorteilhaft die asynchrone PDF-Verarbeitung ist.

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class Program
{
    static async Task Main(string[] args)
    {
        await LongPdfTask();
    }
    static async Task LongPdfTask()
    {
        try
        {
            // Initialize IronPDF's PdfDocument
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);
            // Extract text from PDF asynchronously
            string text = await Task.Run(() => pdf.ExtractAllText()).ConfigureAwait(false);
            // Write the extracted text to a file asynchronously
            await Task.Run(() => File.WriteAllText("extractedText.txt", text)).ConfigureAwait(false);
            Console.WriteLine("Extraction complete!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in GeneratePdfAsync: {ex.Message}");
        }
    }
}

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class Program
{
    static async Task Main(string[] args)
    {
        await LongPdfTask();
    }
    static async Task LongPdfTask()
    {
        try
        {
            // Initialize IronPDF's PdfDocument
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);
            // Extract text from PDF asynchronously
            string text = await Task.Run(() => pdf.ExtractAllText()).ConfigureAwait(false);
            // Write the extracted text to a file asynchronously
            await Task.Run(() => File.WriteAllText("extractedText.txt", text)).ConfigureAwait(false);
            Console.WriteLine("Extraction complete!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in GeneratePdfAsync: {ex.Message}");
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks
Imports System.IO
Imports System
Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		Await LongPdfTask()
	End Function
	Private Shared Async Function LongPdfTask() As Task
		Try
			' Initialize IronPDF's PdfDocument
			Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(False)
			' Extract text from PDF asynchronously
			Dim text As String = Await Task.Run(Function() pdf.ExtractAllText()).ConfigureAwait(False)
			' Write the extracted text to a file asynchronously
			Await Task.Run(Sub() File.WriteAllText("extractedText.txt", text)).ConfigureAwait(False)
			Console.WriteLine("Extraction complete!")
		Catch ex As Exception
			Console.WriteLine($"Error in GeneratePdfAsync: {ex.Message}")
		End Try
	End Function
End Class

Im obigen Code wird `ConfigureAwait(false)` während der großen, zeitaufwändigen Aufgabe verwendet, den gesamten Text aus einer großen PDF-Datei zu extrahieren, die in unserem Fall über 200 Seiten lang war.

• Importe und Einrichtung: Der erste Abschnitt am oberen Ende unseres Codes ist dem Import der notwendigen Bibliotheken und Namensräume gewidmet. Sie müssen sicherstellen, dass Sie `using IronPdf` verwenden, um die IronPDF-Bibliothek zu nutzen.
• Klasse und Hauptmethode: `class Program` definiert die Klasse, die den Hauptanwendungscode für dieses Projekt enthält. **static async Task Main(string[] args)** ist der Einstiegspunkt für die Anwendung. Hier haben wir es als async markiert, damit unsere asynchronen Operationen darin ausgeführt werden können. Dann verwenden wir await LongPdfTask(), um die LongPdfTask-Methode asynchron aufzurufen.

• Try-Block: Ich habe den Code innerhalb der LongPdfTask-Methode in einem Try-Catch-Block eingefasst, um unerwartete Ausnahmen elegant zu behandeln.

  • PdfDocument PDF = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false): Diese Zeile kann in drei verschiedene Segmente unterteilt werden:

    • PdfDocument.FromFile("Sample.pdf"): Dieser Abschnitt lädt die angegebene PDF-Datei synchron in ein IronPdf.PdfDocument-Objekt.

    • await Task.Run(() => ...): Führt den PDF-Ladevorgang in einem separaten Thread aus, um den Hauptthread nicht zu blockieren. Es handelt sich also um einen asynchronen Vorgang.
• .ConfigureAwait(false): Vermeidet das Erfassen des aktuellen Kontexts, was die Leistung verbessern und Deadlocks reduzieren sollte.
• string text = await Task.Run(() => pdf.ExtractAllText()).ConfigureAwait(false): Dies führt die IronPDF-Textextraktionsmethode aus, ExtractAllText(). Erneut wird await Task.Run(() => ...) verwendet, um diesen Vorgang asynchron in einem separaten Thread auszuführen.
• await Task.Run(() => File.WriteAllText("extractedText.txt", text)).ConfigureAwait(false): Damit schreiben wir den extrahierten Text asynchron in eine .txt-Datei, indem wir erneut die Methode await Task verwenden.

Vor

Ausgabe

Best Practices für die Verwendung von ConfigureAwait in .NET-Anwendungen

Wann sollte ConfigureAwait(true) vs. ConfigureAwait(false) verwendet werden?

ConfigureAwait(false) wird am besten verwendet, wenn Sie in Bibliothekscode oder im Hintergrundverarbeitung arbeiten, wo der Synchronisierungskontext nicht beibehalten werden muss. In der Regel handelt es sich um serverseitigen Code, bei dem die Leistung entscheidend ist. Die Verwendung von ConfigureAwait(false) bedeutet, dass die Fortsetzung nach Abschluss der await-Operation nicht unbedingt im selben Thread ausgeführt wird, der die asynchrone Operation gestartet hat.

Bei der PDF-Verarbeitung kann die Implementierung von ConfigureAwait(false) dazu beitragen, die Leistung zu maximieren, wenn mehrere PDF-Verarbeitungsaufgaben ausgeführt werden, um Engpässe im Zusammenhang mit Kontextwechseln zu vermeiden. Sie kann auch dazu beitragen, dass die Anwendung bei der Verarbeitung großer Mengen von PDF-Dateien reibungslos läuft, und sie kann einfach dazu beitragen, die Effizienz in Situationen aufrechtzuerhalten, in denen Sie in Konsolenanwendungen oder Hintergrunddiensten arbeiten, in denen ein Kontextwechsel unnötig sein könnte.

ConfigureAwait(true) wird am besten in UI, bei jedem Unit-Test Ihres Codes oder ASP.NET-Anwendungen verwendet, bei denen die Fortsetzung im selben Kontext ausgeführt werden muss, obwohl dies bei falscher Verwendung zu einem Deadlock führen kann. Zum Beispiel, wenn Sie die Benutzeroberfläche aktualisieren oder auf httpcontext zugreifen. ConfigureAwait(true) ist das Standardverhalten und könnte auch einfach als ConfigureAwait geschrieben werden.

Bei der Verwendung für PDF-Verarbeitungsaufgaben kann es besonders vorteilhaft in Situationen sein, in denen Ihr PDF-Verarbeitungscode eng mit der Benutzeroberfläche integriert ist (bei der Verwendung von UI-Anwendungen wie WPF, WinForms usw.), wie beispielsweise bei der Anzeige des Fortschritts, und Sie den Synchronisierungskontext erfassen müssen, um sicherzustellen, dass diese Aktualisierungen im UI-Thread erfolgen. Sie ist auch bei der Arbeit mit thread-sensitiven Operationen von Vorteil, die aufgrund von Thread-Affinitätsanforderungen auf einem bestimmten Thread ausgeführt werden müssen.

Behandlung von Ausnahmen bei asynchronen IronPDF-Operationen

Die Behandlung von Ausnahmen in der asynchronen Programmierung ist ein wichtiger Aspekt, der sorgfältig bedacht werden muss, denn unbehandelte Ausnahmen können die Anwendung beenden. Die Verwendung von try-catch-Blöcken um asynchronen Code herum ist eine gute Möglichkeit, unerwartete Ausnahmen elegant zu behandeln.

Zum Beispiel:

public async Task SafeGeneratePdfAsync()
{
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);
        await Task.Run(() => pdf.SaveAs("output.pdf")).ConfigureAwait(false);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"An error occurred: {ex.Message}");
    }
}

public async Task SafeGeneratePdfAsync()
{
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);
        await Task.Run(() => pdf.SaveAs("output.pdf")).ConfigureAwait(false);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"An error occurred: {ex.Message}");
    }
}

Public Async Function SafeGeneratePdfAsync() As Task
	Try
		Dim renderer As New ChromePdfRenderer()
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(False)
		Await Task.Run(Function() pdf.SaveAs("output.pdf")).ConfigureAwait(False)
	Catch ex As Exception
		Console.WriteLine($"An error occurred: {ex.Message}")
	End Try
End Function

Beim Verwenden von Fortsetzungsaufgaben mit `ConfigureAwait(false)` können Ausnahmen entweder innerhalb der Fortsetzung mit try-catch behandelt werden oder durch die Eigenschaft Task.Exception, wenn Task.ContinueWith verwendet wird.

Ein Beispiel dafür, wie Sie den Code schreiben könnten, könnte so aussehen:

class program
{
    public static async Task Main(string[] args)
    {
        await ProcessPdfWithContinuationAsync();
    }
    static Task ProcessPdfWithContinuationAsync()
    {
        return Task.Run(() => PdfDocument.FromFile("Sample.pdf"))
            .ContinueWith(pdfTask =>
            {
                if (pdfTask.IsFaulted)
                {
                    // Handle exceptions from loading the PDF
                    Console.WriteLine($"Error loading PDF: {pdfTask.Exception?.GetBaseException().Message}");
                    return;
                }
                var pdf = pdfTask.Result;
                // Extract text asynchronously with exception handling
                Task.Run(() => pdf.ExtractAllText())
                    .ContinueWith(extractTask =>
                    {
                        if (extractTask.IsFaulted)
                        {
                            // Handle exceptions from extracting text
                            Console.WriteLine($"Error extracting text: {extractTask.Exception?.GetBaseException().Message}");
                            return;
                        }
                        // Proceed if text extraction is successful
                        Console.WriteLine("Extracted text:");
                        Console.WriteLine(extractTask.Result);
                    }, TaskContinuationOptions.OnlyOnRanToCompletion);
            }, TaskContinuationOptions.OnlyOnRanToCompletion);
    }

class program
{
    public static async Task Main(string[] args)
    {
        await ProcessPdfWithContinuationAsync();
    }
    static Task ProcessPdfWithContinuationAsync()
    {
        return Task.Run(() => PdfDocument.FromFile("Sample.pdf"))
            .ContinueWith(pdfTask =>
            {
                if (pdfTask.IsFaulted)
                {
                    // Handle exceptions from loading the PDF
                    Console.WriteLine($"Error loading PDF: {pdfTask.Exception?.GetBaseException().Message}");
                    return;
                }
                var pdf = pdfTask.Result;
                // Extract text asynchronously with exception handling
                Task.Run(() => pdf.ExtractAllText())
                    .ContinueWith(extractTask =>
                    {
                        if (extractTask.IsFaulted)
                        {
                            // Handle exceptions from extracting text
                            Console.WriteLine($"Error extracting text: {extractTask.Exception?.GetBaseException().Message}");
                            return;
                        }
                        // Proceed if text extraction is successful
                        Console.WriteLine("Extracted text:");
                        Console.WriteLine(extractTask.Result);
                    }, TaskContinuationOptions.OnlyOnRanToCompletion);
            }, TaskContinuationOptions.OnlyOnRanToCompletion);
    }

Friend Class program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Await ProcessPdfWithContinuationAsync()
	End Function
	Private Shared Function ProcessPdfWithContinuationAsync() As Task
		Return Task.Run(Function() PdfDocument.FromFile("Sample.pdf")).ContinueWith(Sub(pdfTask)
				If pdfTask.IsFaulted Then
					' Handle exceptions from loading the PDF
					Console.WriteLine($"Error loading PDF: {pdfTask.Exception?.GetBaseException().Message}")
					Return
				End If
				Dim pdf = pdfTask.Result
				' Extract text asynchronously with exception handling
				Task.Run(Function() pdf.ExtractAllText()).ContinueWith(Sub(extractTask)
						If extractTask.IsFaulted Then
							' Handle exceptions from extracting text
							Console.WriteLine($"Error extracting text: {extractTask.Exception?.GetBaseException().Message}")
							Return
						End If
						' Proceed if text extraction is successful
						Console.WriteLine("Extracted text:")
						Console.WriteLine(extractTask.Result)
				End Sub, TaskContinuationOptions.OnlyOnRanToCompletion)
		End Sub, TaskContinuationOptions.OnlyOnRanToCompletion)
	End Function

Warum IronPDF für Ihre PDF-Verarbeitungsanforderungen?

Hauptmerkmale und Vorteile von IronPDF

IronPDF ist eine leistungsstarke C# PDF-Bibliothek, die eine Vielzahl von Funktionen für alle PDF-bezogenen Aufgaben bietet. IronPDF for .NET 8, 7, 6, .NET Core, Standard und Framework wird vollständig unterstützt und kann in einer Reihe von Anwendungsumgebungen wie Windows, Linux, Mac, Docker, Azure und AWS ausgeführt werden, so dass Sie unabhängig von Ihrer bevorzugten Umgebung das Beste aus IronPDF herausholen können.

Mit IronPDF können Sie PDFs aus verschiedenen Dateitypen und Datentypen erstellen, einschließlich HTML-Dateien, HTML-Strings, URLs, Bildern, DOCX und RTF, oft in nur wenigen Zeilen Code! Es kann das Format Ihrer PDF-Dokumente bearbeiten, benutzerdefinierte Wasserzeichen anwenden, PDFs zusammenführen und teilen, PDF-Verschlüsselung und Sicherheit verwalten und mehr.

IronPDF's Unterstützung für asynchrone Programmierung

IronPDF bietet asynchrone Methoden für viele seiner Operationen, die es Entwicklern ermöglichen, async/await-Muster nahtlos zu nutzen. Diese Unterstützung stellt sicher, dass IronPDF in leistungskritische Anwendungen integriert werden kann, ohne die Reaktionsfähigkeit zu beeinträchtigen, und macht es zu einem unschätzbaren PDF-Tool für Entwickler, die an PDF-bezogenen Aufgaben in einer asynchronen Umgebung arbeiten.

Lizenzvergabe

Wenn Sie IronPDF selbst ausprobieren und seine breite Palette an Funktionen entdecken möchten, können Sie dies dank der kostenlosen Testversion ganz einfach tun. Dank der schnellen und einfachen Installation können Sie IronPDF im Handumdrehen in Ihren PDF-Projekten einsetzen. Möchten Sie IronPDF weiterhin nutzen und die Vorteile seiner leistungsstarken Funktionen für Ihre PDF-Projekte nutzen? Lizenzen beginnen schon ab $749 und beinhalten eine großzügige 30-Tage-Geld-zurück-Garantie, ein ganzes Jahr Produktunterstützung und Updates und werden als unbefristete Lizenz angeboten (also keine lästigen wiederkehrenden Gebühren!)

C# ConfigureAwait (So funktioniert es für Entwickler): Abbildung 5

Beispiel: Verwendung von ConfigureAwait und IronPDF für die PDF-Erzeugung

Um ein PDF asynchron zu generieren, verwenden wir IronPDF, um Code zum Rendern der HTML-Datei auszuführen und das Ergebnis zu speichern, während wir ConfigureAwait(false) verwenden, um sicherzustellen, dass die Fortsetzung nicht unnötig zum ursprünglichen Synchronisierungskontext zurückwechselt.

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }
    static async Task<string> CreateInvoicePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);
            return filePath;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }
    static async Task<string> CreateInvoicePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);
            return filePath;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks
Imports System.IO
Imports System
Friend Class program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Await CreateInvoicePdfAsync()
	End Function
	Private Shared Async Function CreateInvoicePdfAsync() As Task(Of String)
		Dim renderer As New ChromePdfRenderer()
		Try
			Dim pdf = Await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(False)
			Await Task.Run(Function() pdf.SaveAs("invoice.pdf")).ConfigureAwait(False)
			Return filePath
		Catch ex As Exception
			Console.WriteLine($"Error generating PDF: {ex.Message}")
			Return Nothing
		End Try
	End Function
End Class

In diesem Beispiel verwenden wir die von uns erstellte asynchrone Methode static async TaskCreateInvoicePdfAsync(), um eine PDF-Rechnung aus der HTML-Datei zu generieren, die von der RenderHtmlFileAsPdfAsync-Methode bereitgestellt wird. Wir haben ConfigureAwait(false) verwendet, um die Fortsetzung dieser Aufgabe im ursprünglichen Synchronisierungskontext zu verhindern, was die Leistung unserer Nicht-UI-Anwendung verbessert.

Wir haben die Methode await Task.Run(() => ...) erneut implementiert, um die Operationen asynchron auszuführen. Schließlich haben wir die neu erstellte PDF-Datei mit der Methode pdf.SaveAs als "invoice.pdf" gespeichert. Der gesamte Code innerhalb der CreateInvoicePdfAsync()-Methode wurde in einen Try-Catch-Block eingebettet, um unerwartete Ausnahmen zu behandeln.

HTML-Datei

Ausgabe

Wie Sie sehen, ist es uns gelungen, die HTML-Datei asynchron in eine PDF-Datei umzuwandeln, und es wurde eine übersichtliche, qualitativ hochwertige PDF-Datei für uns erstellt.

Schlussfolgerung

Asynchrones Programmieren ist essentiell für den Aufbau von reaktiven und effizienten .NET-Anwendungen, und die korrekte Verwendung von ConfigureAwait kann Ihnen helfen, optimale Leistung zu erreichen, insbesondere beim Schreiben von Code auf App-Ebene. Beim Arbeiten mit IronPDF sorgt die Nutzung von asynchronen Methoden zusammen mit ConfigureAwait(false) dafür, dass Ihre PDF-Verarbeitungsvorgänge den Hauptthread nicht blockieren, was die allgemeine Reaktionsfähigkeit Ihrer Anwendung verbessert. Indem Sie verstehen, wann und wie Sie ConfigureAwait verwenden, können Sie Ihre IronPDF-PDF-Verarbeitungsaufgaben robuster und leistungsfreundlicher gestalten.

Nun können Sie als Profis ConfigureAwait zusammen mit IronPDF in der asynchronen Programmierung nutzen, also worauf warten Sie noch? Probieren Sie noch heute IronPDF aus, um zu sehen, wie es Ihre PDF-bezogenen Projekte verbessern kann! Wenn Sie mehr über die breite Palette an Funktionen erfahren möchten, die IronPDF als leistungsstarke Allzweck-Bibliothekscode bietet, schauen Sie sich unbedingt die praktischen Anleitungen an. Oder wenn Sie mehr darüber erfahren möchten, wie IronPDF zusammen mit asynchronen Programmiermethoden verwendet wird, oder einfach mehr über IronPDF im Allgemeinen lernen möchten, schauen Sie sich unsere Blogbeiträge an. Wenn Sie nach weiteren Beispielen für asynchrone PDF-Erstellung suchen, sehen Sie sich unseren Beitrag C# Wait For Seconds an oder unseren anderen Beitrag zu C# Task.Run.