Co to jest Async/Await?

Słowa kluczowe async i await są używane do definiowania metod asynchronicznych w C#. Metoda asynchroniczna wykonuje operację bez blokowania wykonania głównego wątku aplikacji, pozwalając aplikacji pozostawać responsywną, nawet gdy wykonuje się długotrwałe zadania.

• async: To słowo kluczowe jest stosowane do metod, które mają wykonywać operacje asynchroniczne. Wskazuje, że metoda zawiera co najmniej jedno wyrażenie await.
• await: To słowo kluczowe służy do wstrzymania wykonania metody, aż do zakończenia oczekiwanego zadania. Zapewnia, że wątek jest wolny, aby wykonywać inne zadania podczas oczekiwania na zakończenie 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 asynchroniczne poprawiają responsywność, zwalniając główny wątek do obsługi innych operacji podczas oczekiwania na ukończenie zadań.

Kluczowe korzyści z programowania asynchronicznego

• Operacje nieblokujące: W programowaniu asynchronicznym, czasochłonne operacje (takie jak operacje I/O na plikach lub zapytania sieciowe) nie blokują głównego wątku. Jest to kluczowe dla aplikacji webowych, gdzie operacje nieblokujące zapewniają możliwość obsługi wielu żądań serwera jednocześnie.
• Poprawiona skalowalność: Słowo kluczowe async pozwala aplikacji obsługiwać więcej współbieżnych operacji przy mniejszej liczbie wątków, poprawiając skalowalność.
• Lepsze doświadczenia użytkownika: Dla aplikacji desktopowych lub webowych operacje asynchroniczne zapewniają, że interfejs użytkownika pozostaje responsywny na dane wejściowe użytkownika, podczas gdy zadania są wykonywane w tle.

Przegląd IronPDF

IronPDF pozwala programistom .NET na integrację funkcjonalności PDF bezpośrednio w swoich aplikacjach, zarówno w środowiskach webowych, jak i desktopowych. Oto niektóre z kluczowych funkcji oferowanych przez IronPDF:

• Konwersja HTML do PDF: IronPDF może przekształcić HTML (w tym CSS, obrazy i JavaScript) w pełni sformatowane PDF-y. Jest to szczególnie użyteczne w przypadku renderowania dynamicznych stron internetowych lub raportów jako PDF.
• Edycja PDF: Dzięki IronPDF można manipulować istniejącymi dokumentami PDF, dodając tekst, obrazy i grafiki, a także edytować zawartość istniejących stron.
• Ekstrakcja tekstu i obrazów: Biblioteka pozwala na ekstrakcję tekstu i obrazów z PDF-ów, ułatwiając analizę i analizę zawartości PDF.
• Wypełnianie formularzy: IronPDF obsługuje wypełnianie pól formularzy w PDF-ach, co jest przydatne do generowania spersonalizowanych dokumentów.
• Znakowanie: Możliwe jest także dodawanie znaków wodnych do dokumentów PDF w celach brandingowych lub ochrony praw autorskich.

Dlaczego warto używać IronPDF z Async/Await?

Choć IronPDF nie jest natywnie asynchroniczny, dobrze pasuje do wzorców async/await ze względu na charakter zadań związanych z I/O przy przetwarzaniu PDF. Na przykład konwersja HTML do PDF lub ładowanie dużego dokumentu PDF może zająć znaczną ilość czasu, ale można to zrobić asynchronicznie, aby uniknąć blokowania głównego wątku.

Oto kilka przykładów, jak IronPDF dobrze pasuje do programowania asynchronicznego:

• Generowanie PDF: Jeśli twoja aplikacja musi generować wiele PDF-ów na podstawie dynamicznej treści, uruchamianie tych procesów asynchronicznie pozwala systemowi pozostać responsywnym, gdy PDF-y są tworzone.
• Manipulacja PDF: Jeśli potrzebujesz modyfikować duże PDF-y, takie jak dodawanie znaków wodnych czy łączenie dokumentów, wykonywanie tych zadań asynchronicznie zapewnia, że twoja aplikacja nie zawiesza się podczas przetwarzania tych czasochłonnych operacji w tle.
• Operacje I/O na plikach: Odczytywanie i zapisywanie plików PDF to operacja zależna od I/O. Programowanie asynchroniczne jest idealne dla tych zadań, ponieważ uwalnia zasoby systemowe i unika niepotrzebnego blokowania.

Podstawowy przykład: Asynchroniczne generowanie PDF z IronPDF

Oto przykład pisania kodu asynchronicznego z IronPDF w celu wygenerowania 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 do PDF: Klasa ChromePdfRenderer jest używana do konwersji zawartości HTML na PDF. W tym przykładzie przekazujemy prostą zawartość HTML jako ciąg znaków ("

   Async PDF Example

   "), ale w rzeczywistej aplikacji może to być dynamiczny HTML, na przykład szablon raportu.

2. Korzystanie z Task.Run do asynchronicznego generowania PDF: Metoda RenderHtmlAsPdf nie jest domyślnie asynchroniczna, więc używamy Task.Run(), aby przenieść generowanie PDF na wątek w tle. Jest to ważne, ponieważ generowanie PDF może być zasobożerne i czasochłonne, zwłaszcza przy pracy z dużymi lub złożonymi dokumentami.

3. Zapisywanie PDF: Po wygenerowaniu PDF, jest on zapisywany w systemie plików za pomocą pdf.SaveAs(). Ta operacja I/O jest również owinięta w Task.Run(), aby zapewnić, że nie blokuje głównego wątku podczas zapisywania pliku.

4. Oczekiwanie na operacje: Słowo kluczowe await zapewnia, że każda operacja asynchroniczna zostanie ukończona, zanim rozpocznie się kolejna. Podczas oczekiwania na zakończenie generowania PDF, główny wątek pozostaje wolny, aby obsługiwać inne zadania (np. obsługę innych żądań HTTP w aplikacji webowej).

Obsługa wielu zadań z IronPDF

Dla aplikacji obsługujących duże pliki PDF może być konieczne wykonywanie wielu operacji, takich jak dzielenie, łączenie czy dodawanie zawartości do dużych plików. Korzystanie z async zapewnia, że podczas gdy jedna operacja jest przetwarzana, aplikacja pozostaje responsywna na dane wejściowe użytkownika lub żądania.

Na przykład można połączyć wiele operacji asynchronicznych w potoku:

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 ładujemy plik PDF i tworzymy nowy, dodajemy znak wodny, łączymy dwa PDF-y i zapisujemy wszystko bez blokowania głównego wątku.

Najlepsze praktyki dla operacji asynchronicznych z IronPDF

• Uwagi dotyczące puli wątków: Ponieważ IronPDF polega na wątkach w tle do przetwarzania, należy pamiętać o puli wątków przy używaniu Task.Run(). Dla częstych zadań rozważ użycie dedykowanej usługi w tle lub kolejkowanie zadań, aby uniknąć przeciążenia puli wątków.
• Unikaj metod async void: Zawsze używaj async Task do metod, które wykonują operacje asynchroniczne. Zarezerwuj metody async void do obsługi zdarzeń.
• Tokeny anulowania: Dla długotrwałych operacji, takich jak generowanie PDF lub ekstrakcja tekstu, warto wspierać tokeny anulowania, aby umożliwić użytkownikom przerwanie operacji, jeśli to potrzebne. Zapewnia to, że zasoby są zwalniane, jeśli operacja nie jest już 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

• Obsługa błędów: Jak w przypadku każdej operacji asynchronicznej, upewnij się, że masz odpowiednią obsługę błędów dla wyjątków, które mogą wystąpić podczas przetwarzania PDF, takich jak problemy z dostępem do pliku czy nieprawidłowe dane wejściowe.

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