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

Asenkron Programlama Nedir?

Asenkron programlama, bazı işlemlerin ana uygulama iş parçacığından bağımsız olarak çalışmasına izin veren bir kod yazma yöntemini ifade eder. Bu, beklemenin gerekli olduğu, I/O işlemleri gibi uzun süren görevler için kullanışlıdır. Bu görevlerin ana iş parçacığını engellemeden çalışmasına izin vererek, uygulama bu görevler tamamlanırken çalışmaya devam edebilir ve sonuçta uygulamanın performansını ve yanıt verme yeteneğini artırır.

Asenkron Koddaki ConfigureAwait Rolü

ConfigureAwait, bir bekleme ifadesinden sonra çalışacak kod olan bir devamın nasıl yürütüleceğini kontrol etmek için asenkron programlamada kullanılan bir yöntemdir. Devam await ifadesinden sonra çalışan koddur, varsayılan olarak await mevcut bağlamı yakalar ve devamı o bağlamda yeniden yürütmeye çalışır, bu etkisiz olabilir. ConfigureAwait, devamın yakalanan bağlamda (işaretlenmiş: ConfigureAwait(true)) çalıştırılıp çalıştırılmayacağını belirtmenize olanak tanır veya çalıştırılmaması (işaretlenmiş: ConfigureAwait(false)) gerektiğini gösterir.

ConfigureAwait(false) kullanmak kilitlenmelerden kaçınmaya yardımcı olur, çünkü bunu kullandığınızda, göreve mevcut eşitleme bağlamını yakalamamasını ve orijinal bağlamda devam etmeye çalışmamasını söylüyorsunuz. Bu, devamın orijinal konteksten ziyade bir iş parçacığı havuzu iş parçacığında çalışmasına izin verir, böylece ana iş parçacığının engellenmesini önler.

ConfigureAwait(false), özellikle kütüphane kodlarında veya orijinal bağlama yeniden başlamanın gereksiz olduğu durumlarda faydalı olur, bu sayede kodun esnek ve kilitlenmesiz kalmasını sağlar.

.NET Projenizde IronPDF Kurulumu

.NET projelerinizde IronPDF 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 yolunu izleyip IronPDF arayarak gerçekleştirebilirsiniz:

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

Veya alternatif olarak, Paket Yöneticisi Konsolu'nda aşağıdaki komutu çalıştırarak:

Install-Package IronPdf

Kodunuzda IronPDF kullanmaya başlamak için, using IronPdf; ifadesini kod dosyanızın üst kısmına yerleştirdiğinizden emin olun. IronPDF'yi ortamınıza kurmak için daha derin bir rehber için başlarken sayfasını kontrol edin.

IronPDF Kullanarak Asenkron Olarak PDF Oluşturma

Büyük miktarda PDF dosyası oluşturmanız gereken veya aynı anda birden çok işlem gerçekleştirmek istediğiniz durumlarda PDF dosyalarını asenkron olarak oluşturmak özellikle yararlı olabilir. IronPDF ile, asenkron olarak PDF ile ilgili görevleri 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() yönteminde bir PDF belgesi asenkron olarak oluşturduk. ChromePdfRenderer, HTML içeriğinden bir PDF dosyası oluşturmada hayati olan oluşturucuyu yaratmak için kullanılır. PdfDocument sınıfı, sağlanan HTML dizgesinden bir PDF oluşturmak için kullanılır, ancak aynı zamanda bir HTML dosyasından, bir URL'den, bir görüntüden ve daha fazlasından PDF oluşturmak için de kullanılabilir. IronPDF ile PDF üretmenin farklı yöntemleri hakkında daha fazla bilgi için, nasıl yapılır bölümüne göz atın.

Büyük PDF Dosyalarıyla Asenkron Çalışma

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ılır

ConfigureAwait(false), senkronizasyon bağlamının korunmasına gerek olmayan kütüphane kodu veya arka plan işlemlerinde en iyi şekilde kullanılır. Genellikle, bu performansın kritik olduğu sunucu tarafı kodlar içindir. ConfigureAwait(false) kullanmak, await işlemi bittiğinde devamın asenkron işlemi başlatan aynı iş parçacığında çalışmasının gerekmediğini ifade eder.

PDF işleme söz konusu olduğunda, ConfigureAwait(false) uygularsanız, bağlam değiştirme ile ilgili dar boğazlardan kaçınmaya yardımcı olmak için birden çok PDF işleme görevi çalıştırırken performansı maksimuma çıkarabilir. Bu, büyük miktarda PDF dosyası işlerken uygulamanın sorunsuz çalışmasına yardımcı olabilir, ayrıca bağlam değiştirmenin gereksiz olduğu konsol uygulamaları veya arka plan servislerinde verimliliği korumaya yardımcı olur.

ConfigureAwait(true) ise UI, kodunuzun herhangi bir birim testi veya sürekliliğin aynı bağlamda çalışması gerektiği ASP.NET uygulamaları için en iyi şekilde kullanılır, ancak yanlış kullanılırsa deadlock'a yol açabilir. Örneğin, kullanıcı arayüzünü güncelliyorsanız veya httpcontext'e erişiyorsanız. ConfigureAwait(true) varsayılan davranıştır ve sadece ConfigureAwait olarak da yazılabilir.

PDF işleme görevleriyle kullanıldığında, özellikle kullanıcı arayüzüyle (WPF, WinForms gibi) sıkı bir şekilde entegre olmuşsa ve bu güncellemelerin UI iş parçacığında gerçekleşmesini sağlamak için senkronizasyon bağlamını yakalamanız gerekiyorsa faydalı olabilir. Ayrıca, iş parçacığına duyarlı işlemlerle çalışırken de faydalıdır, çünkü iş parçacığı ilişkisi gereksinimleri nedeniyle belirli bir iş parçacığında yürütülmesi gerekir.

Asenkron IronPDF İşlemlerinde Hataları Yönetme

Asenkron programlamada hataları yönetmek, akılda tutulması gereken önemli bir husustur ve dikkatli düşünmeyi gerektirir; yönetilmeyen hatalar uygulamayı sonlandırabilir. Asenkron kod etrafında try-catch blokları kullanmak, beklenmedik hataları zarif bir şekilde yönetmenin 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, try-catch ile devam içinde istisnalar işlenebilir veya Task.ContinueWith kullanılıyorsa Task.Exception özelliği ile işlenebilir.

Bunu yapmak için nasıl bir kod yazabileceğinize dair bir örnek şöyle görünebilir:

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 Temel Özellikleri ve Avantajları

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

IronPDF, tüm PDF ile ilgili 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 destek ile, Windows, Linux, Mac, Docker, Azure ve AWS gibi bir dizi uygulama ortamında çalışabilen IronPDF'i, tercih ettiğiniz ortam ne olursa olsun en iyi şekilde kullanabileceksiniz.

IronPDF ile çeşitli dosya ve veri türlerinden, HTML dosyaları, HTML dizeleri, URL'ler, görseller, DOCX ve RTF dahil olmak üzere PDF'ler oluşturabilirsiniz, genellikle sadece birkaç satır kodla! PDF belgelerinizin formatlamasını yapabilir, özel filigranlar uygulayabilir, PDF'leri birleştirip bölebilir, PDF şifreleme ve güvenlik gibi işlemleri halledebilir ve daha fazlasını yapabilirsiniz.

IronPDF'in Asenkron Programlamaya Desteği

IronPDF, birçok operasyon için asenkron yöntemler sağlayarak, geliştiricilerin async/await kalıplarını sorunsuz bir şekilde kullanmasına olanak tanır. Bu destek, performans açısından kritik uygulamalara IronPDF'in entegrasyonunu, yanıt verme hızı kaybetmeden sağlamaktadır; bu da asenkron ortamlarda PDF ile ilgili görevler üzerinde çalışan geliştiriciler için değerli bir PDF aracıdır.

Lisanslama

IronPDF'i kendiniz denemek ve geniş özellik yelpazesini keşfetmek istiyorsanız, ücretsiz deneme süresi sayesinde bunu kolayca yapabilirsiniz. Hızlı ve kolay kurulumu sayesinde IronPDF'i PDF projelerinize kısa sürede kurabilirsiniz. Güçlü özelliklerini kullanarak PDF oyununuzu bir üst seviyeye taşımak için devam etmek ister misiniz? Lisanslar sadece $999'den başlar ve cömert 30 günlük para iade garantisi, bir yıl boyunca ürün desteği ve güncellemeleriyle gelir, ve bir süresiz lisans olarak sunulur (Yani sürekli tekrarlayan ücretler yoktur!)

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

Bir PDF'i asenkron olarak oluşturmak için, HTML dosyasını işlemek ve sonucu kaydetmek için IronPDF'i kullanacağız; bu sırada ConfigureAwait(false) kullanarak devamın orijinal senkronizasyon bağlamına gereksiz yere geçiş yapmamasını sağlayacağı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, sağlanan HTML dosyasından bir PDF fatura oluşturmak için oluşturduğumuz asenkron yöntemi, static async Task CreateInvoicePdfAsync(), kullanıyoruz. Bu görevin orijinal senkronizasyon bağlamında devam etmesini önlemek ve uygulamamızın performansını artırmak için ConfigureAwait(false) kullandık.

İşlemleri asenkron olarak çalıştırmak için tekrar await Task.Run()) => ...) yöntemini uyguladık. Son olarak, yeni oluşturulan PDF dosyasını pdf.SaveAs yöntemiyle "fatura.pdf" olarak kaydettik. CreateInvoicePdfAsync() yöntemindeki tüm kod, beklenmeyen hataları yönetmek için bir try-catch bloğu içine alınmıştır.

HTML Dosyası

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

Çıktı

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

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