C# ConfigureAwait (Geliştiriciler İçin Nasıl Çalışır)

Asenkron Programlama Nedir?

Asenkron programlama, ana uygulama dizininden bağımsız olarak çalışan belirli işlemler yazmayı sağlayan bir kod yazma yöntemidir. Bu yöntem, I/O işlemleri gibi bekleme gerektiren uzun süreli görevler için kullanışlıdır. Bu görevlerin ana dizini engellemeden çalışmasına izin vererek, uygulama bu görevler tamamlanırken çalışmaya devam eder, bu da uygulamanın performansını ve yanıt verebilirliğini nihayetinde artırır.

Asenkron Kodda ConfigureAwait'in Rolü

ConfigureAwait, bir devam işleminin nasıl yürütüleceğini kontrol etmek için kullanılan bir asenkron programlama yöntemidir. Devam işlemi, varsayılan olarak, bir await ifadesinden sonra çalışan koddur. await geçerli durumu yakalar ve devam işlemini bu duruma geri marshal etmeye çalışır, bu etkisiz olabilir. ConfigureAwait, devam işleminin yakalanan durumda çalıştırılıp çalıştırılmayacağını, ConfigureAwait(true) olarak belirtilir, veya ConfigureAwait(false) ile belirtilmeden çalıştırılıp çalıştırılmayacağını belirtmenize olanak tanır.

ConfigureAwait(false) kullanmak deadlocklardan kaçınmaya yardımcı olur çünkü bunu kullanırken, görevden geçerli senkronizasyon bağlamını yakalamamasını ve orijinal bağlamda devam etmemesi gerektiğini söylüyorsunuz. Bu durum, devam işleminin ilk bağlam yerine bir dizin havuzu dizininde çalışmasına izin verir, bu nedenle ana dizinin engellenmesini önler.

ConfigureAwait(false) kütüphane kodunda veya orijinal bağlama devam etmenin gereksiz olduğu durumlarda özellikle yararlıdır, böylece kodun esnek ve deadlocklardan kaçınır hale gelir.

.NET Projenizde IronPDF'i Kurmak

.NET projelerinizde IronPDF'i kullanmaya başlamak için, IronPDF NuGet paketini kurarak başlayın. Bunu, Araçlar > NuGet Paket Yöneticisi > Çözüm için NuGet Paket Yöneticisi'ni ziyaret ederek ve IronPDF arayarak yapabilirsiniz:

Alternatif olarak, Paket Yöneticisi Konsolunda aşağıdaki komutu çalıştırabilirsiniz:

Install-Package IronPdf

Kodunuzda IronPDF kullanmaya başlamak için, using IronPdf; ifadesini kod dosyanızın üstünde bulundurun. IronPDF'yi ortamınıza kurmak için daha kapsamlı bir rehber için, başlangıç sayfasına göz atın.

IronPDF Kullanarak Asenkron Olarak PDF Oluşturma

PDF dosyalarını asenkron olarak oluşturmak, özellikle büyük miktarda PDF dosyası oluşturduğunuz veya birden fazla işlemi eşzamanlı yapmak istediğiniz durumlarda faydalı olabilir. IronPDF ile PDF ile ilgili görevleri asenkron olarak gerçekleştirebilirsiniz, bu da aşağıdaki asenkron kod gibi görünebilir:

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

Bu kodda, GeneratePdfAsync() metodunda asenkron bir şekilde bir PDF belgesi oluşturduk. ChromePdfRenderer, HTML içeriğinden PDF dosyası oluşturmak için gerekli bir render oluşturmakta kullanılır. PdfDocument sınıfı, sağlanan HTML dizgenizden PDF oluşturmak için kullanılır, ancak, HTML dosyası, URL, görsel ve daha fazlasından PDF oluşturmak için de kullanılabilir. IronPDF ile PDF oluşturmanın farklı yöntemleri hakkında daha fazla bilgi için, PDF oluşturma konusunda nasıl yapılır bölümüne göz atın.

Büyük PDF Dosyalarını Asenkron Olarak Çalıştırma

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

ConfigureAwait(true) ve ConfigureAwait(false) Ne Zaman Kullanılmalı

ConfigureAwait(false), kütüphane kodunda veya senkronizasyon bağlamının korunmasına gerek olmayan arka plan işlemlerinde çalışırken en iyi şekilde kullanılır. Genellikle performansın kritik olduğu sunucu tarafı kodlar içindir. ConfigureAwait(false) kullandığınızda, await işlemi tamamlandığında, devam işlemi asenkron işlemi başlatan aynı dizinde çalışmak zorunda değildir.

PDF işlemleri söz konusu olduğunda, ConfigureAwait(false) kullanmak, bağlam değişimlerine bağlı darboğazları önlemeye yardımcı olacak birden fazla PDF işleme görevini yürütürken performansı en üst düzeye çıkarmaya yardımcı olabilir. Büyük miktarda PDF dosyası işlerken ve sadece konsol uygulamaları veya arka plan hizmetlerinde çalışırken, bağlam değişiminin gereksiz olabileceği durumlarda projeyi sorunsuz kılmaya yardımcı olabilir.

ConfigureAwait(true) UI, kodunuz için herhangi bir birim testi veya devam işleminin aynı bağlamda çalışması gereken ASP.NET uygulamalarında en iyi şekilde kullanılır, ancak yanlış kullanılırsa ölümcül kilitlenmeye neden olabilir. Örneğin, UI'yi güncellemek veya httpcontext'e erişmek. ConfigureAwait(true) varsayılan davranıştır ve yalnızca ConfigureAwait olarak da yazılabilir.

PDF işleme görevleriyle kullanıldığında, özellikle PDF işleme kodunuzun UI ile sıkı bir şekilde entegre olduğu durumlarda (UI uygulamaları, WPF, WinForms vb. gibi) faydalı olabilir, yani ilerlemeyi gösterme, ve bu güncellemelerin UI dizininde olduğundan emin olmak için senkronizasyon bağlamını yaklamanız gerekir. Aynı zamanda belirli bir dizinde yürütülmesi gereken, dizin duyarlılığından dolayı belirli bir dizinde yürütülmesi gereken dizin duyarlı işlemlerle çalışırken de faydalıdır.

Asenkron IronPDF işlevlerinde İstisnaları Yönetme

Asenkron programlamada istisnaları ele almak, dikkate alınması gereken önemli bir husustur ve dikkatli düşünmeyi gerektirir ve ele alınmayan istisnalar uygulamanın sonlanmasına yol açabilir. Asenkron kod çevresine try-catch blokları kullanmak, beklenmedik istisnaları zarifle ele almanın harika bir yoludur.

Örneğin:

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

ConfigureAwait(false) ile devam görevleri kullanırken, istisnalar, devam içerisinde try-catch kullanılarak veya Task.ContinueWith kullanılıyorsa Task.Exception özelliği tarafından ele alınabilir.

Bu durumu yapmak için nasıl kod yazabileceğinize dair bir örnek şunlara benzeyebilir:

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

IronPDF'in Anahtar Özellikleri ve Avantajları

IronPDF, PDF ile ilgili tüm görevleriniz için zengin bir özellik seti sunan güçlü bir C# PDF kütüphanesidir. .NET 8, 7, 6, .NET Core, Standard ve Framework için tam destekle, Windows, Linux, Mac, Docker, Azure ve AWS gibi bir dizi uygulama ortamında çalışabiliyor, tercih ettiğiniz ortam ne olursa olsun IronPDF'in en iyi şekilde kullanılmasını sağlar.

IronPDF ile çeşitli dosya ve veri türlerinden PDF'ler oluşturabilirsiniz; HTML dosyaları, HTML dizgeleri, URL'ler, görseller, DOCX ve RTF, genellikle sadece birkaç kod satırında! PDF belgelerinizin formatlamasını yönetebilir, özelleştirilmiş filigranlar uygulayabilir, PDF'leri birleştirip bölebilir, PDF şifreleme ve güvenlik ve daha fazlasını yapabilirsiniz.

IronPDF'in Asenkron Programlamayı Desteklemesi

IronPDF, birçok işlemi için asenkron yöntemler sağlar, bu da geliştiricilerin async/await desenlerini sorunsuz bir şekilde kullanmasına olanak tanır. Bu destek, demektir ki IronPDF, performans-önemli uygulamalara entegre edilebilirken yanıt sürelerinden feragat etmeden, onu asenkron bir ortamda PDF ile ilgili görevler üzerinde çalışan geliştiriciler için paha biçilmez bir araç haline getirir.

Lisanslama

IronPDF'i kendiniz deneyimlemek ve geniş özelliklerini keşfetmek istiyorsanız, deneme lisansı sayesinde bunu kolayca gerçekleştirebilirsiniz. Hızlı ve kolay kurulumuyla, IronPDF'i PDF projelerinizde hemen çalışır hale getirebilirsiniz. Güçlü özelliklerinden yararlanarak PDF becerilerinizi geliştirmeye devam etmek istiyor musunuz? Lisanslar sadece $799'dan başlar ve cömert bir 30 günlük para iade garantisi, bir yıl boyunca ürün desteği ve güncellemeleriyle gelir, ayrıca bunun bir kalıcı lisans olarak gelir (Yani rahatsız edici yenilenen ücretler yok!)

Bir PDF'i asenkron bir şekilde oluşturmak için, HTML dosyasını işleme kodunu çalıştırmak ve sonucu kaydetmek için IronPDF'i kullanacağız, aynı zamanda devam işleminin gereksiz yere orijinal senkronizasyon bağlamına geri dönmesini sağlamamak için ConfigureAwait(false) kullanacağız.

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

Bu örnekte, oluşturduğumuz asenkron yöntemi, static async Task CreateInvoicePdfAsync(), RenderHtmlFileAsPdfAsync yöntemi tarafından sağlanan HTML dosyasından bir PDF faturasını oluşturmak için kullanıyoruz. Bu görevde devamın orijinal senkronizasyon bağlamında devamını önlemek için ConfigureAwait(false) kullandık, bu da kullanıcı arayüzü olmayan uygulamamızın performansını artırıyor.

Operasyonları asenkron olarak çalıştırmak için await Task.Run()) => ...) yöntemini tekrar uyguladık. Son olarak, yeni oluşturulan PDF dosyasını pdf.SaveAs yöntemi kullanarak "invoice.pdf" olarak kaydettik. Beklenmedik istisnaları ele almak için tüm CreateInvoicePdfAsync() yöntemi, bir try-catch bloğu içerisine alınmıştır.

HTML Dosyası

Çıktı

Gördüğünüz gibi, HTML dosyasını asenkron olarak başarıyla bir PDF'e dönüştürdük ve bizim için net, yüksek kaliteli bir PDF dosyası yarattı.