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(falsch)\So können Sie in bestimmten Szenarien Deadlocks vermeiden. Deadlocks treten in der asynchronen Programmierung auf, wenn es einen Synchronisationskontext gibt(wie z. B. ein UI-Thread in einer Desktop-Anwendung) der erwartet, dass ein Vorgang abgeschlossen ist, bevor er fortgesetzt wird. Dennoch wartet die erwartete Aufgabe darauf, dass der Synchronisierungskontext verfügbar ist, was zu einer Warteschleife führt.

Heute werden wir untersuchen, wieConfigureAwait kann mit IronPDF verwendet werden, um PDF-Verarbeitungsaufgaben durch asynchrone Programmierung effizient durchzufü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, mit der gesteuert wird, wie eine Fortsetzung 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 verfrachten, was ineffektiv sein kann. mit ConfigureAwait können Sie angeben, ob die Fortsetzung im erfassten Kontext ausgeführt werden soll, angegeben als `ConfigureAwait(wahr)*" oder nicht, angegeben durch "ConfigureAwait(falsch)`.

Verwenden von `ConfigureAwait(falsch)\" hilft dabei, Deadlocks zu vermeiden, denn wenn Sie es verwenden, weisen Sie die Aufgabe an, den aktuellen Synchronisationskontext nicht zu erfassen und nicht zu versuchen, mit dem 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(falsch)\" ist besonders nützlich in Bibliothekscode oder in Fällen, in denen eine Wiederaufnahme des ursprünglichen Kontexts unnötig ist, wodurch sichergestellt wird, 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, installieren Sie zunächst dieIronPDF NuGet-Paket. 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 Codedatei platziert haben. Eine ausführlichere Anleitung zur Einrichtung von IronPDF in Ihrer Umgebung finden Sie in dererste Schritte seite.

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 GeneratePdfAsync() Methode. ChromePdfRenderer wird verwendet, um den Renderer zu erstellen, der für die Erstellung einer PDF-Datei aus dem HTML-Inhalt unerlässlich ist. DiePdfDocument klasse wird verwendet, um ein PDF aus den bereitgestellten Daten zu erstellenHTML-Stringsie können aber auch eine PDF-Datei aus einem anderen Dokument erstellenHTML-Datei, URL, bildund mehr. Weitere Informationen zu den verschiedenen Methoden der PDF-Erstellung mit IronPDF finden Sie in derhow-to-Abschnitt zur Erstellung von PDFs.

Asynchrones Arbeiten mit großen PDF-Dateien

Beim Umgang mit großen PDF-Dateien ist die Verwendung asynchroner Methoden mit `ConfigureAwait(falsch)` kann die Leistung erheblich verbessern, indem es den Haupt-Thread bei langwierigen Operationen entlastet. Für dieses Beispiel habe ich ein großes PDF-Dokument genommen und einetextextraktion die Aufgabe besteht darin, die Vorteile der asynchronen PDF-Verarbeitung zu demonstrieren.

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(falsch)bei der großen, zeitaufwändigen Aufgabe, den gesamten Text aus einer großen PDF-Datei zu extrahieren, die in unserem Fall über 200 Seiten lang war, wird *\" verwendet.

• Import und Einrichtung: Der erste Abschnitt am Anfang unseres Codes ist dem Import der erforderlichen Bibliotheken und Namespaces gewidmet. Sie müssen sicherstellen, dass Sie IronPdf verwenden, um die IronPDF-Bibliothek nutzen zu können
• Klasse und Hauptmethode: `Klasse Programm` 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 sie als async markiert, damit unsere asynchronen Operationen von ihr aus ausgeführt werden können. Dann verwenden wir await LongPdfTask() die Methode LongPdfTask asynchron aufzurufen.

• Try Block: Ich habe den Code innerhalb der LongPdfTask-Methode in einen try-catch-Block verpackt, um unerwartete Ausnahmen elegant zu behandeln.

  • PdfDocument PDF = await Task.Run(() => PdfDocument.FromFile("Beispiel.pdf")).ConfigureAwait(falsch): Dieser Bereich kann in drei verschiedene Segmente unterteilt werden:

    • PdfDocument.FromFile("Beispiel.pdf"): Dieser Abschnitt lädt die angegebene PDF-Datei synchron in eineIronPdf.PdfDocument objekt.

    • **await Task.Run(() => ...)lässt den PDF-Ladevorgang auf einem separaten Thread laufen, um ein Blockieren des Hauptthreads zu vermeiden. Es handelt sich also um einen asynchronen Vorgang.
• .ConfigureAwait(falsch): Es wird vermieden, den aktuellen Kontext zu erfassen, was die Leistung verbessern und Deadlocks reduzieren soll.
• string text = await Task.Run(() => pdf.ExtractAllText()).ConfigureAwait(falsch): Dies ist dieIronPDF Textextraktion methode,ExtractAllText(). Nochmals: Warte auf Task.Run(() => ...) wird verwendet, um diesen Vorgang asynchron in einem separaten Thread auszuführen.
• await Task.Run(() => File.WriteAllText("extractedText.txt", text)).ConfigureAwait(falsch)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(wahr) vs. ConfigureAwait(falsch) verwendet werden?

ConfigureAwait(falsch) ist am besten geeignet, wenn Sie in Bibliothekscode oder Hintergrundverarbeitung arbeiten, wo der Synchronisationskontext nicht erhalten bleiben muss. In der Regel handelt es sich um serverseitigen Code, bei dem die Leistung entscheidend ist. Verwendung von ConfigureAwait(falsch) bedeutet, dass nach Beendigung der await-Operation die Fortsetzung nicht unbedingt auf demselben Thread läuft, der die asynchrone Operation gestartet hat.

Wenn es um PDF-Verarbeitung geht, ist die Implementierung von ConfigureAwait(falsch) kann 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(wahr) eignet sich am besten für UI, Unit-Tests für Ihren Code oder ASP.NET-Anwendungen, bei denen die Fortsetzung im gleichen Kontext ausgeführt werden muss, obwohl sie bei falscher Anwendung zu einem Deadlock führen kann. Wenn Sie zum Beispiel die Benutzeroberfläche aktualisieren oder auf httpcontext zugreifen). ConfigureAwait(wahr) ist das Standardverhalten und könnte auch einfach als ConfigureAwait geschrieben werden.

Bei der Verwendung mit PDF-Verarbeitungsaufgaben kann es besonders vorteilhaft sein, wenn Ihr PDF-Verarbeitungscode eng mit der Benutzeroberfläche integriert ist(bei der Verwendung von UI-Anwendungen wie WPF, WinForms, etc)sie müssen den Synchronisationskontext erfassen, um sicherzustellen, dass diese Aktualisierungen auf dem 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

Bei der Verwendung von Fortsetzungsaufgaben mit `ConfigureAwait(falsch)\Ausnahmen können mit try-catch innerhalb der Fortsetzung oder mit der Eigenschaft Task.Exception bei Verwendung von Task.ContinueWith behandelt werden.

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 Datei- und Datentypen erzeugen, darunterHTML-Dateien, HTML-String, URLs, bilder, DOCXundRTFoft in nur wenigen Codezeilen! Es kann die Formatierung Ihrer PDF-Dokumente übernehmen, diebenutzerdefinierte Wasserzeichen, zusammenführen und Aufteilen von PDFs, behandelnPDF-Verschlüsselung undsicherheitund 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 vielfältigen Funktionen erkunden möchten, können Sie dies dank der folgenden Website ganz einfach tunkostenloser Test zeitraum. 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? Lizenzenbeginnen bei nur $749, und kommen mit einer großzügigen 30-Tage-Geld-zurück-Garantie, einem ganzen Jahr Produktunterstützung und Updates und kommen als zeitlich unbegrenzte Lizenz(Also keine lästigen wiederkehrenden Gebühren!)

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

Um ein PDF asynchron zu generieren, werden wir IronPDF verwenden, um den Code zum Rendern der HTML-Datei auszuführen und das Ergebnis zu speichern, während wir ConfigureAwait(falsch) Der Übersetzer muss sicherstellen, dass die Fortsetzung nicht unnötigerweise in den ursprünglichen Synchronisationskontext zurückspringt.

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 async-Methode static async TaskCreateInvoicePdfAsync(), um eine PDF-Rechnung aus der HTML-Datei zu generieren, die von derRenderHtmlFileAsPdfAsync methode. Wir haben ConfigureAwait(falsch) die Fortsetzung dieser Aufgabe im ursprünglichen Synchronisationskontext zu verhindern und die Leistung unserer Nicht-UI-Anwendung zu verbessern.

Wir haben auch die await Task.Run()) => ...) Methode, 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() Die Methode wurde in einen try-catch-Block eingeschlossen, 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

Asynchrone Programmierung ist für die Erstellung reaktionsschneller und effizienter .NET-Anwendungen und die Verwendung vonConfigureAwait kann Ihnen helfen, eine optimale Leistung zu erzielen, insbesondere beim Schreiben von Code auf Anwendungsebene. Bei der Arbeit mitIronPDFdie Übersetzung soll den Einsatz asynchroner Methoden zusammen mit ConfigureAwait(falsch) stellt sicher, dass Ihre PDF-Verarbeitungsaufgaben den Haupt-Thread nicht blockieren, wodurch die Reaktionsfähigkeit Ihrer Anwendung insgesamt verbessert wird. Wenn Sie verstehen, wann und wie Sie ConfigureAwait verwenden, können Sie Ihre IronPDF PDF-Verarbeitungsaufgaben robuster und leistungsfreundlicher gestalten.

Jetzt können Sie als Profis ConfigureAwait zusammen mit IronPDF in der asynchronen Programmierung einsetzen, worauf warten Sie also noch? Testen Sie IronPDF noch heute, um zu sehen, wie es Ihre PDF-Projekte verbessern kann! Wenn Sie mehr über die breite Palette an Funktionen erfahren möchten, die IronPDF als leistungsstarke Allzweckbibliothek zu bieten hat, sollten Sie sich den praktischen Code ansehengebrauchsanweisungen. Wenn Sie mehr über die Verwendung von IronPDF in Verbindung mit asynchronen Programmiermethoden lesen oder einfach mehr über IronPDF im Allgemeinen erfahren möchten, besuchen Sie unserenblog-Beiträge. Wenn Sie nach weiteren Beispielen für die asynchrone PDF-Erzeugung suchen, sehen Sie sich unsereC# Wait For Seconds beitrag, oder unser anderer Beitrag aufC# Task.Run.