Czym jest Async/Await?

Slowa kluczowe async i await sa używane do definiowania metod asynchronicznych w C#. Metoda asynchroniczna wykonuje operacje bez blokowania wykonywania głównego watku aplikacji, pozwalając aplikacji pozostac responsywna, nawet gdy wykonuje dlugie zadania.

• async: To slowo kluczowe jest stosowane do metod, ktore maja wykonywać operacje asynchroniczne. Wskazuje, ze metoda zawiera przynajmniej jedno wyrazenie await.
• await: To slowo kluczowe jest używane do wstrzymania wykonania metody, dopoki czekane zadanie nie zostanie zakonczone. Zapewnia, ze wątek jest wolny do wykonywania innych zadań wczasie oczekiwania na zakonczenie operacji.

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

Public Async Function WaitExampleAsync() As Task
	Await Task.Delay(1000) ' Waits for 1 second without blocking the thread
	Console.WriteLine("Finished waiting asynchronously!")
End Function

Metody async poprawiaja responsywność, uwalniajac główny wątek, aby obsługiwal inne operacje, podczas gdy czeka sie na zakonczenie zadań.

Kluczowe korzysci programowania asynchronicznego

• Operacje nieblokujace: Z programowaniem asynchronicznym czasochlonne operacje (takie jak operacje I/O na plikach czy zadania sieciowe) nie blokuja głównego watku. To kluczowe dla aplikacji webowych, gdzie operacje nieblokujace zapewniają, ze serwer może obsluzyc wiele zapytan jednoczesnie.
• Poprawiona skalowalnosc: Slowo kluczowe async pozwala aplikacji obsługiwac więcej jednoczesnych operacji przy użyciu mniejszej liczby wątków, poprawiajac skalowalnosc.
• Lepsze doswiadczenie użytkownika: Dla aplikacji desktopowych lub webowych operacje asynchroniczne zapewniają, ze UI pozostaje responsywny na wejscia użytkownika, gdy zadania sa wykonywane w tle.

Przegląd IronPDF

IronPDF pozwala programistom .NET zintegrowac funkcjonalność PDF bezpośrednio w swoich aplikacjach, niezależnie czy sa to rozwiązania webowe czy desktopowe. Oto niektóre z kluczowych funkcji oferowanych przez IronPDF:

• Konwersja HTML do PDF: IronPDF może konwertować zawartość HTML (w tym CSS, obrazy i JavaScript) na w pelni sformatowane PDF. Jest to szczególnie przydatne do renderowania dynamicznych stron internetowych lub raportów w formacie PDF.
• Edytowanie PDF: Z IronPDF można manipulowac istniejącymi dokumentami PDF, dodajac tekst, obrazy i grafiki, a także edytujac zawartość istniejących stron.
• Ekstrakcja tekstu i obrazów: Biblioteka pozwala wyciagac tekst i obrazy z PDF, co ułatwia analizowanie i przetwarzanie zawartości.
• Wypelnianie formularzy: IronPDF wspiera wypelnianie pol formularzy w PDF, co jest przydatne do generowania spersonalizowanych dokumentów.
• Dodawanie znakow wodnych: Mozliwe jest również dodawanie znakow wodnych do dokumentów PDF w celu brandingu lub ochrony praw autorskich.

Dlaczego używać IronPDF z Async/Await?

Chociaż IronPDF nie jest natywnie asynchroniczny, doskonale pasuje do wzorcow async/await ze wzgledu na charakter zadań zależnych od I/O w przetwarzaniu PDF. Na przykład, konwersja HTML do PDF lub ladowanie duzego dokumentu PDF może zajac znaczna ilosc czasu, ale można to zrobic asynchronicznie, aby uniknąć blokowania głównego watku.

Oto kilka przykładów, jak IronPDF doskonale wpasowuje sie w programowanie asynchroniczne:

• Generowanie PDF: Jeśli aplikacja musi generować wiele plików PDF na podstawie dynamicznej zawartości, asynchroniczne wykonywanie tych procesów pozwala systemowi pozostac responsywnym, gdy PDF sa tworzone.
• Manipulacja PDF: Jeśli trzeba modyfikowac duze pliki PDF, takie jak dodawanie znakow wodnych lub scałanie dokumentów, wykonywanie tych zadań asynchronicznie zapewnia, ze aplikacja nie wisi, gdy te czasochlonne operacje sa przetwarzane w tle.
• Operacje I/O na plikach: Odczytyw i zapis do plików PDF to operacje zalezne od I/O. Programowanie asynchroniczne jest idealne dla tych zadań, poniewaz uwalnia zasoby systemowe i unika niepotrzebnego blokowania.

Podstawowy przykład: Asynchroniczne generowanie PDF z IronPDF

Oto przykład pisania kodu asynchronicznego z IronPDF do generowania pliku PDF:

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Initialize renderer
		Dim renderer As New ChromePdfRenderer()

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"))

		' Save the generated PDF to a file
		Await Task.Run(Function() pdf.SaveAs("output.pdf"))
	End Function
End Class

Jak to działa

1. Tworzenie konwertera HTML na PDF: Klasa ChromePdfRenderer jest uzywana do konwersji tresci HTML do PDF. In this example, we pass simple HTML content as a string ("

   Async PDF Example

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

2. Użycie Task.Run do asynchronicznego generowania PDF: Metoda RenderHtmlAsPdf nie jest domyslnie asynchroniczna, dlatego uzywamy Task.Run(), aby odciazyc proces generowania PDF na watek tle. To ważne, poniewaz generowanie PDF może być zasobochlonne i czasochlonne, szczegółnie przy pracy z duzymi lub skomplikowanymi dokumentami.

3. Zapisywanie PDF: Po wygenerowaniu pliku PDF jest on zapisywany w systemie plikow przy uzyciu pdf.SaveAs(). Ta operacja I/O jest rowniez opisana za pomoca Task.Run(), aby zapewnic, ze nie blokuje glownego watku podczas zapisu pliku.

4. Oczekiwanie na operacje: Slowo kluczowe await zapewnia, ze kazda asynchroniczna operacja zostanie zakonczona, zanim rozpocznie sie nastepna. Podczas oczekiwania na zakonczenie generowania PDF główny wątek pozostaje wolny, aby obsługiwac inne zadania (np. obsługę innych zapytan HTTP w aplikacji webowej).

Obsluga wielu zadań z IronPDF

W przypadku aplikacji obslugujacych duze PDF, może być konieczne wykonanie wielu operacji, takich jak dzielenie, scałanie lub dodawanie zawartości do duzych plików. Uzycie async zapewnia, ze podczas przetwarzania jednej operacji aplikacja pozostaje responsywna na wejscia lub zapytania użytkownika.

Na przykład, można połączyć wiele operacji async w pipeline:

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim renderer As New ChromePdfRenderer()
		Dim page As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>")

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("output.pdf"))

		' Perform some operations asynchronously
		Await Task.Run(Function() pdf.ApplyWatermark("Confidential"))

		Dim merged As PdfDocument = Await Task.Run(Function() PdfDocument.Merge(pdf, page))
		Await Task.Run(Function() merged.SaveAs("processed_output.pdf"))
	End Function
End Class

W tym przykładzie ladowanie pliku PDF i tworzenie nowego, dodawanie znaku wodnego, scałanie dwoch PDF i ich zapisywanie, odbywa sie bez blokowania głównego watku.

Najlepsze praktyki operacji asynchronicznych z IronPDF

• Uwagi dotyczace poolu watkow: Poniewaz IronPDF polega na watkach tle do przetwarzania, nalezy zwracac uwage na pool watkow przy korzystaniu z Task.Run(). Dla zadań o wysokiej częstotliwosci, rozwaz użycie dedykowanej usługi w tle lub kolejkowanie zadań, aby uniknąć przeciazenia puli wątków.
• Unikaj metod async void: Zawsze uzywaj async Task dla metod wykonujacych operacje asynchroniczne. Zarezerwuj metody async void dla obsługiwania zdarzen.
• Tokeny anulowania: Dla dlugo trwałych operacji, takich jak generowanie PDF lub ekstrakcja tekstu, warto wspierac tokeny anulowania, aby umożliwić użytkownikom anulowanie operacji, jeśli będą tego potrzebowac. To zapewnia, ze zasoby zostana zwolnione, jeśli operacja nie jest juz potrzebna.

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

Public Async Function GeneratePdfWithCancellationAsync(ByVal cancellationToken As CancellationToken) As Task
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken)

	If cancellationToken.IsCancellationRequested Then
		Console.WriteLine("Operation was canceled.")
		Return
	End If
	pdf.SaveAs("output.pdf")
End Function

• Obsluga błędów: Tak jak przy kazdej operacji asynchronicznej, upewnij sie, ze prawidłowo obsługujesz wyjątki, ktore mogą wystapic podczas przetwarzania PDF, takie jak problemy z dostepem do plików czy nieprawidlowe dane wejsciowe.

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Try
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"))
	pdf.SaveAs("output.pdf")
Catch ex As Exception
	Console.WriteLine($"Error: {ex.Message}")
End Try