C# ConfigureAwait (Jak to dziala dla programistow)

Czym jest programowanie asynchroniczne?

Programowanie asynchroniczne odnosi sie do metody pisania kodu, która pozwala na wykonywanie pewnych operacji niezależnie od głównego watku aplikacji. Jest to przydatne dla dlugo trwajacych zadań wymagajacych oczekiwania, takich jak operacje wejscia/wyjscia. Pozwalajac na wykonywanie tych zadań bez blokowania głównego watku, aplikacja może dalej działać, podczas gdy te zadania trwaja, co ostatecznie poprawia wydajność oraz responsywność aplikacji.

Rola ConfigureAwait w kodzie asynchronicznym

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

Używanie ConfigureAwait(false) pomaga unikać zakleszczeń, ponieważ kiedy go używasz, instruujesz zadanie, aby nie przechwytywało bieżącego kontekstu synchronizacji i nie próbowało wznowić w pierwotnym kontekście. To pozwala kontynuacji uruchomic sie na watku puli wątków zamiast oryginalnego kontekstu, dzięki czemu główny wątek nie zostaje zablokowany.

ConfigureAwait(false) jest szczególnie przydatne w kodzie biblioteki lub w przypadkach, gdzie wznawianie pierwotnego kontekstu nie jest konieczne, zapewniając tym samym, że kod pozostaje elastyczny i wolny od zakleszczeń.

Konfiguracja IronPDF w projekcie .NET

Aby zaczac korzystać z IronPDF w projektach .NET, zacznij od zainstalowania IronPDF NuGet package. Możesz to zrobic przechodzac do Tools > NuGet Package Manager > NuGet Package Manager for Solution i wyszukujac IronPDF:

Alternatywnie, uruchom następujące polecenie w konsoli Package Manager Console:

Install-Package IronPdf

Aby rozpocząć używanie IronPDF w swoim kodzie, upewnij się, że umieściłeś instrukcję using IronPdf; na początku pliku kodu. Aby uzyskać bardziej szczegółowy przewodnik dotyczący konfigurowania IronPDF w swoim środowisku, zajrzyj na jego stronę startową.

Generowanie PDF asynchronicznie za pomoca IronPDF

Generowanie plików PDF asynchronicznie może być szczegółnie korzystne w sytuacjach, gdy trzeba generować duze ilosci plików PDF lub chcesz wykonywać wiele operacji jednoczesnie. Za pomoca IronPDF możesz wykonywać zadania związane z PDF asynchronicznie, co może wyglądac jak poniższy 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 stworzyliśmy dokument PDF asynchronicznie w metodzie GeneratePdfAsync(). ChromePdfRenderer jest używany do stworzenia renderera niezbędnego do tworzenia pliku PDF z treści HTML. Klasa PdfDocument jest używana do tworzenia PDF z dostarczonego napisu HTML, jednakze możesz tez uzyc jej do stworzenia PDF z pliku HTML, URL, obrazka i innych. Aby dowiedziec sie więcej o różnych metodach generowania PDF za pomoca IronPDF, odwiedz sekcje how-to dotycząca generowania PDF.

Praca z duzymi 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 w tle, gdzie kontekst synchronizacji nie musi być zachowany. Zazwyczaj to dotyczy kodu po stronie serwera, gdzie wydajność jest kluczowa. Uzycie ConfigureAwait(false) oznacza, ze gdy operacja await sie konczy, kontynuacja niekoniecznie musi działać na tym samym watku, ktory rozpoczal operacje asynchroniczna.

Jeśli chodzi o przetwarzanie PDF, wdrożenie ConfigureAwait(false) może pomoc w maksymalizacji wydajności podczas uruchamiania wielu zadań przetwarzania PDF w celu unikniecia waskich gardeł związanych z przełączaniem kontekstu. Może również pomoc w plynnej pracy aplikacji podczas przetwarzania duzej ilosci plików PDF oraz utrzymywaniu efektywności w sytuacjach, w ktorych pracujesz w aplikacjach konsolowych lub w usługach wsadowych, gdzie przełączanie kontekstu mogłoby być niepotrzebne.

ConfigureAwait(true) najlepiej używać w interfejsie użytkownika, testach jednostkowych dla Twojego kodu, lub aplikacjach ASP.NET, gdzie kontynuacja musi działać w tym samym kontekście, choc nieprawidlowa jego użycie może prowadzic do zakleszczen. Na przykład, gdy aktualizujesz interfejs użytkownika lub dostep do httpcontext). ConfigureAwait(true) jest domyslnym zachowaniem i można go również zapisać jako po prostu ConfigureAwait.

Gdy używany jest w zadaniach przetwarzania PDF, może być szczegółnie korzystny w sytuacjach, takich jak gdy kod przetwarzania PDF jest ścisle zintegrowany z UI (podczas korzystania z aplikacji UI, takich jak WPF, WinForms, itp.), takich jak wyswietlanie postępu, i musisz przechwycic kontekst synchronizacji, aby zapewnic, ze te aktualizacje odbywaja sie na watku UI. Jest również korzystny podczas pracy z operacjami wymagającymi specyficznego watku ze względu na wymagania związane z przywiâzaniami wątku.

Obsluga wyjątków w operacjach asynchronicznych IronPDF

Obsluga wyjątków w programowaniu asynchronicznym to ważny aspekt, który należy mieć na uwadze, i wymaga starannego rozwazenia, a nieobsługiwane wyjątki mogą zakonczyc działanie aplikacji. Korzystanie z blokow try-catch wokół kodu asynchronicznego jest świetnym sposobem na eleganckie radzenie sobie z niespodziewanymi 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

Kiedy używasz zadań kontynuacyjnych z ConfigureAwait(false), wyjątki można obsługiwać za pomocą try-catch w ramach kontynuacji, lub przez właściwość Task.Exception jeśli używasz Task.ContinueWith.

Przyklad, jak moglbys zapisać kod, aby to zrobic, moglby wyglądac 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 funkcje i zalety IronPDF

IronPDF to potężna biblioteka C# PDF, która oferuje bogaty zestaw funkcji do wszystkich zadań związanych z PDF. Z pełna obsługa .NET 8, 7, 6, .NET Core, Standard i Framework, i zdolnoscia działania w szerokim zakresie srodowisk aplikacji, takich jak Windows, Linux, Mac, Docker, Azure i AWS, będziezs w stanie wyciagnac maksa z IronPDF bez wzgledu na preferowane środowisko.

Za pomoca IronPDF możesz generować PDF z różnych typow plików i danych; w tym plików HTML, napisow HTML, URL, obrazkow, DOCX i RTF, często w zaledwie kilku linijkach kodu! Może zajmowac sie formatowaniem dokumentów PDF, nakladac indywidualne znaki wodne, scałac i dzielic PDF, zajmowac sie szyfrowaniem PDF i zabezpieczeniami i wiele więcej.

Obsluga programowania asynchronicznego przez IronPDF

IronPDF udostepnia asynchroniczne metody dla wielu swoich operacji, pozwalając programistom bezproblemowo wykorzystywac wzorce async/await. Ta obsługa zapewnia, ze IronPDF może być zintegrowany z aplikacjami krytycznymi dla wydajności bez pogarszania reagowalnosci, czyniac go nieocenionym narzędziem PDF dla deweloperow pracujacych nad zadaniami związanymi z PDF w środowisku asynchronicznym.

Licencjonowanie

Jeśli chcesz wypróbować IronPDF samodzielnie i zbadac szeroki zakres jego funkcji, możesz to łatwo zrobic dzięki darmowy okres próbny. Dzięki szybkiemu i łatwemu procesu instalacji, będziesz w stanie uruchomic IronPDF w projektach PDF w krotkim czasie. Chcesz kontynuowac korzystanie z jego potężnych funkcji, aby podniesc poziom w swoich projektach PDF? Licencje zaczynają się od zaledwie $999, i obejmują hojną 30-dniową gwarancję zwrotu pieniędzy, pełny rok wsparcia produktu i aktualizacji, a także są wydawane jako licencja wieczysta (bez uciążliwych opłat cyklicznych!)

Aby generować PDF asynchronicznie, uzyjemy IronPDF do wykonania kodu renderującego plik HTML i zapisania wyniku, używając ConfigureAwait(false), aby upewnic sie, ze kontynuacja nie przelacza sie niepotrzebnie z powrotem do oryginalnego kontekstu 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 metody async, która stworzyliśmy, static async Task CreateInvoicePdfAsync(), aby wygenerować fakture PDF z pliku HTML dostarczonego przez metode RenderHtmlFileAsPdfAsync. Uzyliśmy ConfigureAwait(false), aby zapobiec kontynuowaniu tego zadania w oryginalnym kontekście synchronizacji, poprawiając wydajność naszej aplikacji bez UI.

Zimplementowalismy również metode await Task.Run()) => ...) po raz kolejny, aby uruchomic operacje asynchronicznie. Na koniec zapisaliśmy nowo wygenerowany plik PDF jako "invoice.pdf" używając metody pdf.SaveAs. Caly kod w metodzie CreateInvoicePdfAsync() zostal umieszczony w blok try-catch, aby radzic sobie z wszelkimi niespodziewanymi wyjątkami.

Plik HTML

Wynik

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