C# ConfigureAwait (Jak to dziala dla programistow)

Czym jest programowanie asynchroniczne?

Programowanie asynchroniczne odnosi się do metody pisania kodu, która pozwala na wykonywanie niektórych operacji niezależnie od głównego wątku aplikacji. Jest to przydatne w przypadku zadań długotrwałych wymagających oczekiwania, takich jak operacje I/O. Pozwalając na wykonanie tych zadań bez blokowania głównego wątku, aplikacja może nadal działać, podczas gdy te zadania zajmują czas na zakończenie, ostatecznie poprawiając wydajność i responsywność aplikacji.

Rola ConfigureAwait w kodzie asynchronicznym

ConfigureAwait to metoda w programowaniu asynchronicznym używana do kontrolowania sposobu, w jaki wykonywana jest kontynuacja. Kontynuacja to kod, który działa po wyrażeniu await, domyślnie await przechwytuje bieżący kontekst i próbuje przekazać kontynuację z powrotem do tego kontekstu, co może być nieskuteczne. ConfigureAwait pozwala określić, czy kontynuacja powinna być uruchomiona w przechwyconym kontekście, oznaczonym jako ConfigureAwait(true), czy nie, oznaczone jako ConfigureAwait(false).

Użycie ConfigureAwait(false) pomaga uniknąć zakleszczeń, ponieważ gdy go używasz, mówisz zadaniu, aby nie przechwytywało bieżącego kontekstu synchronizacji i nie próbowało wznawiać na oryginalnym kontekście. Pozwala to na uruchomienie kontynuacji na wątku puli wątków zamiast na oryginalnym kontekście, co zapobiega blokowaniu głównego wątku.

ConfigureAwait(false) jest szczególnie przydatne w kodzie biblioteki lub w przypadkach, gdy wznawianie oryginalnego kontekstu jest niepotrzebne, zapewniając, że kod pozostaje elastyczny i wolny od zakleszczeń.

Konfigurowanie IronPDF w Twoim projekcie .NET

Aby rozpocząć korzystanie z IronPDF w projektach .NET, zacznij od zainstalowania pakietu NuGet IronPDF. Możesz to zrobić, przechodząc do Narzędzia > Menedżer pakietów NuGet > Menedżer pakietów NuGet dla rozwiązania i szukając IronPDF:

Lub alternatywnie, uruchamiając następujące polecenie w konsoli menedżera pakietów:

Install-Package IronPdf

Aby rozpocząć używanie IronPDF w kodzie, upewnij się, że na początku swojego pliku z kodem umieściłeś instrukcję using IronPdf;. Dla bardziej szczegółowego przewodnika dotyczącego konfigurowania IronPDF w Twoim środowisku, sprawdź stronę zaczynamy.

Generowanie plików PDF asynchronicznie za pomocą IronPDF

Generowanie plików PDF asynchronicznie może być szczególnie korzystne w sytuacjach, gdy musisz wygenerować dużą ilość plików PDF lub chcesz wykonywać wiele operacji równocześnie. Z IronPDF możesz wykonywać zadania związane z PDF asynchronicznie, co może wyglądać jak następujący kod asynchroniczny:

using IronPdf;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await GeneratePdfAsync();
    }

    static async Task GeneratePdfAsync()
    {
        // Create a new instance of ChromePdfRenderer.
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Example HTML content to be converted into a PDF.
        string htmlContent = "<h1>Hello World!</h1>";

        // Asynchronously render the HTML content as a PDF document.
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);

        // Asynchronously save the PDF document to a file.
        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()
    {
        // Create a new instance of ChromePdfRenderer.
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Example HTML content to be converted into a PDF.
        string htmlContent = "<h1>Hello World!</h1>";

        // Asynchronously render the HTML content as a PDF document.
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);

        // Asynchronously save the PDF document to a file.
        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
		' Create a new instance of ChromePdfRenderer.
		Dim renderer As New ChromePdfRenderer()

		' Example HTML content to be converted into a PDF.
		Dim htmlContent As String = "<h1>Hello World!</h1>"

		' Asynchronously render the HTML content as a PDF document.
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync(htmlContent)

		' Asynchronously save the PDF document to a file.
		Await Task.Run(Function() pdf.SaveAs("outputAsync.pdf"))

		Console.WriteLine("Working!")
	End Function
End Class

W tym kodzie utworzyliśmy dokument PDF asynchronicznie w metodzie GeneratePdfAsync(). ChromePdfRenderer jest używany do utworzenia renderera, który jest niezbędny w tworzeniu pliku PDF z treści HTML. Klasa PdfDocument jest używana do stworzenia PDF z dostarczonego ciągu HTML, jednak można go również użyć do stworzenia PDF z pliku HTML, adresu URL, obrazu i więcej. Więcej informacji na temat różnych metod generowania PDF z IronPDF znajdziesz w sekcji jak to zrobić dotyczącej generowania PDF.

Praca z dużymi plikami PDF asynchronicznie

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 asynchronously.
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);

            // Extract text from PDF asynchronously with ConfigureAwait to prevent context capture.
            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 LongPdfTask: {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 asynchronously.
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);

            // Extract text from PDF asynchronously with ConfigureAwait to prevent context capture.
            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 LongPdfTask: {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 asynchronously.
			Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(False)

			' Extract text from PDF asynchronously with ConfigureAwait to prevent context capture.
			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 LongPdfTask: {ex.Message}")
		End Try
	End Function
End Class

Kiedy używać ConfigureAwait(true) vs. ConfigureAwait(false)

ConfigureAwait(false) najlepiej używać, gdy pracujesz w kodzie biblioteki lub przetwarzaniu tła, gdzie kontekst synchronizacji nie musi być zachowany. Zwykle dotyczy to kodu po stronie serwera, gdzie wydajność jest krytyczna. Użycie ConfigureAwait(false) oznacza, że kiedy operacja await jest zakończona, kontynuacja niekoniecznie jest uruchamiana na tym samym wątku, który rozpoczął operację asynchroniczną.

Jeśli chodzi o przetwarzanie PDF, stosowanie ConfigureAwait(false) może pomóc w maksymalizacji wydajności podczas uruchamiania wielu zadań przetwarzania PDF, co pomaga unikać wąskich gardeł związanych z przełączaniem kontekstu. Może również pomóc w płynnym działaniu aplikacji, gdy przetwarzane są duże ilości plików PDF, a także utrzymywać efektywność w sytuacjach, w których pracujesz w aplikacjach konsolowych lub usługach tła, gdzie przełączanie kontekstu może być niepotrzebne.

ConfigureAwait(true) najlepiej używać w aplikacjach UI, w jakimkolwiek kodzie testu jednostkowego dla twojego kodu lub aplikacjach ASP.NET, gdzie kontynuacja musi być uruchamiana na tym samym kontekście, chociaż jeśli używane nieprawidłowo, może prowadzić do zakleszczenia. Na przykład, jeśli aktualizujesz UI lub uzyskujesz dostęp do httpcontext). ConfigureAwait(true) to domyślne zachowanie i można to również zapisać jako ConfigureAwait.

Gdy używane razem z zadaniami przetwarzania PDF, może być szczególnie korzystne w sytuacjach, takich jak jeśli twój kod przetwarzania PDF jest ściśle zintegrowany z UI (podczas używania aplikacji UI, takich jak WPF, WinForms, itd.), na przykład wyświetlanie postępu, i musisz przechwytywać kontekst synchronizacji, aby zapewnić, że te aktualizacje odbywają się na wątku UI. Jest to również korzystne, gdy pracujesz z operacjami wrażliwymi na wątki, które muszą być wykonane na konkretnym wątku z powodu wymagań przywiązania wątku.

Obsługa wyjątków w asynchronicznych operacjach IronPDF

Obsługa wyjątków w programowaniu asynchronicznym jest ważnym aspektem, który należy mieć na uwadze, a nieobsługiwane wyjątki mogą zakończyć działanie aplikacji. Użycie bloków try-catch wokół kodu asynchronicznego to doskonały sposób na eleganckie radzenie sobie z nieoczekiwanymi wyjątkami.

Na przykład:

public async Task SafeGeneratePdfAsync()
{
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Asynchronously render HTML as PDF and do not capture the context
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);

        // Asynchronously save PDF to file
        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();

        // Asynchronously render HTML as PDF and do not capture the context
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);

        // Asynchronously save PDF to file
        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()

		' Asynchronously render HTML as PDF and do not capture the context
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(False)

		' Asynchronously save PDF to file
		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

Podczas korzystania z zadań kontynuacji z ConfigureAwait(false) wyjątki mogą być obsługiwane za pomocą try-catch wewnątrz kontynuacji lub przez właściwość Task.Exception, jeśli używasz Task.ContinueWith.

Przykład, jak można napisać kod, aby to zrobić, mógłby wyglądać tak:

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
End Class

Kluczowe cechy i zalety IronPDF

IronPDF to potężna biblioteka PDF C#, oferująca bogaty zestaw funkcji do wszystkich zadań związanych z PDF. Dzięki pełnemu wsparciu dla .NET 8, 7, 6, .NET Core, Standard i Framework, oraz możliwości działania w różnorodnych środowiskach aplikacji takich jak Windows, Linux, Mac, Docker, Azure i AWS, będziesz w stanie w pełni wykorzystać IronPDF, niezależnie od preferowanego środowiska.

Z IronPDF możesz generować PDF z różnych typów plików i danych, w tym plików HTML, ciągu HTML, adresów URL, obrazów, DOCX i RTF, często w zaledwie kilku liniach kodu! Może obsługiwać formatowanie twoich dokumentów PDF, stosować niestandardowe znaki wodne, łączenie i rozdzielanie PDF, obsługę szyfrowania PDF i zabezpieczeń i wiele więcej.

Wsparcie IronPDF dla programowania asynchronicznego

IronPDF zapewnia metody asynchroniczne dla wielu swoich operacji, umożliwiając deweloperom korzystanie z wzorców async/await bezproblemowo. To wsparcie zapewnia, że IronPDF może być zintegrowane z aplikacjami o krytycznym znaczeniu dla wydajności bez poświęcania responsywności, co czyni go nieocenionym narzędziem PDF dla deweloperów pracujących nad zadaniami związanych z PDF w środowisku asynchronicznym.

Licencjonowanie

Jeśli chcesz spróbować IronPDF samodzielnie i odkryć jego szeroką gamę funkcji, możesz to łatwo zrobić dzięki okresowi bezpłatnego okresu próbnego. Dzięki szybkiej i łatwej instalacji będziesz mógł mieć IronPDF uruchomiony w swoich projektach PDF w krótkim czasie. Chcesz nadal korzystać z niego i wykorzystywać jego potężne funkcje, aby podnieść poziom swoich projektów związanych z PDF? Licencje zaczynają się od zaledwie $799, i są objęte hojną 30-dniową gwarancją zwrotu pieniędzy, całym rokiem wsparcia produktu i aktualizacji oraz są oferowane jako licencja wieczysta (więc bez uporczywych opłat cyklicznych!)

Aby wygenerować PDF asynchronicznie, użyjemy IronPDF do wykonywania kodu do renderowania pliku HTML i zapisania wyniku, używając ConfigureAwait(false), aby upewnić się, że kontynuacja nie przełącza się niepotrzebnie z powrotem na oryginalny kontekst synchronizacji.

using IronPdf;
using System.Threading.Tasks;
using System;

class Program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }

    static async Task<string> CreateInvoicePdfAsync()
    {
        // Instance of ChromePdfRenderer to convert HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            // Render HTML file as a PDF asynchronously without capturing the context.
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);

            // Save the generated PDF asynchronously.
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);

            return "invoice.pdf";
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

using IronPdf;
using System.Threading.Tasks;
using System;

class Program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }

    static async Task<string> CreateInvoicePdfAsync()
    {
        // Instance of ChromePdfRenderer to convert HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            // Render HTML file as a PDF asynchronously without capturing the context.
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);

            // Save the generated PDF asynchronously.
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);

            return "invoice.pdf";
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks
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)
		' Instance of ChromePdfRenderer to convert HTML to PDF
		Dim renderer As New ChromePdfRenderer()
		Try
			' Render HTML file as a PDF asynchronously without capturing the context.
			Dim pdf = Await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(False)

			' Save the generated PDF asynchronously.
			Await Task.Run(Function() pdf.SaveAs("invoice.pdf")).ConfigureAwait(False)

			Return "invoice.pdf"
		Catch ex As Exception
			Console.WriteLine($"Error generating PDF: {ex.Message}")
			Return Nothing
		End Try
	End Function
End Class

W tym przykładzie używamy stworzonej przez nas metody async, static async Task CreateInvoicePdfAsync(), do generowania faktury PDF z pliku HTML dostarczonego przez metodę RenderHtmlFileAsPdfAsync. Użyliśmy ConfigureAwait(false), aby zapobiec kontynuacji tego zadania w oryginalnym kontekście synchronizacji, poprawiając wydajność naszej aplikacji nie-UI.

Zaimplementowaliśmy także metodę await Task.Run(() => ...) ponownie do uruchomienia operacji asynchronicznie. Wreszcie zapisaliśmy nowo wygenerowany plik PDF jako "invoice.pdf" za pomocą metody pdf.SaveAs. Cały kod w metodzie CreateInvoicePdfAsync() został zamknięty wewnątrz bloku try-catch, aby obsługiwać wszelkie nieoczekiwane wyjątki.

Plik HTML

Wynik

Jak widać, pomyślnie wygenerowaliśmy plik HTML do PDF asynchronicznie, tworząc dla nas wyraźny, wysokiej jakości plik PDF.