.NET 帮助

C# ConfigureAwait（面向开发人员的工作原理）

雷根·彭

2024年十月24日

作为一名开发人员，异步编程是非常有益的，它可以提高应用程序的性能、效率和响应速度，尤其是那些需要花费大量时间才能完成的操作。使用 `ConfigureAwait(错误)` 在某些情况下可以避免死锁。在异步编程中，如果存在同步上下文，就会出现死锁。(如桌面应用程序中的用户界面线程)在翻译过程中，译员必须确保翻译的准确性，同时解释这些开发人员工具的功能和优点。但是，等待的任务仍在等待同步上下文可用，这就造成了循环等待。

今天，我们将探讨如何配置等待可与 IronPDF 配合使用，通过异步编程高效执行 PDF 处理任务。 IronPDF for .NET 是一个.NET PDF 库，可让处理 PDF 相关任务变得轻而易举。凭借强大的功能集、强大的跨平台兼容性和丰富的文档，它是开发人员工具包中不可或缺的强大 PDF 工具。

了解 C# 异步编程；

什么是异步编程？

异步编程是指允许某些操作独立于主应用程序线程运行的代码编写方法。这对于需要等待的长时间运行任务（如 I/O 操作）非常有用。通过允许这些任务在不阻塞主线程的情况下运行，应用程序可以在这些任务需要时间完成时继续运行，最终提高应用程序的性能和响应速度。

ConfigureAwait 在异步代码中的作用

ConfigureAwait是异步编程中的一种方法，用于控制继续执行的方式。 Continuation 是在 await 表达式之后运行的代码，默认情况下，"await/"会捕获当前上下文，并尝试将 continuation marshal 回到该上下文，这可能是无效的。 **ConfigureAwait** 允许你指定是否应在捕获的上下文中运行续程，表示为 \ConfigureAwait(真)\是否使用**ConfigureAwait表示(错误)`.

使用 `ConfigureAwait(错误)`有助于避免死锁，这是因为当您使用它时，您是在告诉任务不要捕获当前的同步上下文，不要试图在原始上下文上恢复。这样就可以在线程池线程上而不是在原始上下文中继续运行，从而防止主线程被阻塞。

\等待配置(错误)**`在库代码或无需恢复原上下文的情况下尤其有用，从而确保代码保持灵活性和无死锁。

如何将 ConfigureAwait 与 IronPdf 结合使用

在您的 .NET 项目中设置 IronPDF

要开始在您的 .NET 项目中使用 IronPDF，请先安装IronPDF NuGet 软件包. 您可以通过导航至工具 > NuGet Package Manager > NuGet Package Manager for Solution 并搜索 IronPdf 来完成：

C# ConfigureAwait（如何为开发人员工作）：图 1

或在软件包管理器控制台中运行以下命令：

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

要开始在代码中使用 IronPDF，请确保已在代码文件顶部放置了 "using IronPdf"语句。有关在您的环境中设置 IronPDF 的更深入指南，请查阅其入门page.

使用 IronPDF 异步生成 PDFs

异步生成 PDF 文件在需要生成大量 PDF 文件或希望同时执行多个操作的情况下尤其有益。使用 IronPDF，您可以异步执行与 PDF 相关的任务，这可能类似于下面的异步代码：

using IronPdf;
using System.Threading.Tasks;
class program
{
    static async Task Main(string[] args)
    {
        await GeneratePdfAsync();
    }
    static async Task GeneratePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        string htmlContent = "<h1>Hello World!</h1>";
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
        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()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        string htmlContent = "<h1>Hello World!</h1>";
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
        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
		Dim renderer As New ChromePdfRenderer()
		Dim htmlContent As String = "<h1>Hello World!</h1>"
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync(htmlContent)
		Await Task.Run(Function() pdf.SaveAs("outputAsync.pdf"))
		Console.WriteLine("Working!")
	End Function
End Class

在这段代码中，我们通过 GeneratePdfAsync 异步创建了一个 PDF 文档。() 方法。 ChromePdfRenderer该工具用于创建渲染器，而渲染器对于从 HTML 内容创建 PDF 文件至关重要。 "(《世界人权宣言》)PdfDocument该类用于从提供的文档中创建 PDFHTML 字符串您也可以用它来创建 PDF 文件。HTML 文件, 网址, 图像，以及更多。有关使用 IronPDF 生成 PDF 的不同方法的更多信息，请查看如何使用部分关于生成 PDF。

异步处理大型 PDF 文件

在处理大型 PDF 文件时，使用带有 `ConfigureAwait 的异步方法(错误)` 可以在长时间操作时释放主线程，从而大大提高性能。在本示例中，我采用了一个大型 PDF 文档，并进行了如下翻译文本提取任务：演示异步 PDF 处理的好处。

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
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);
            // Extract text from PDF asynchronously
            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 GeneratePdfAsync: {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
            PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(false);
            // Extract text from PDF asynchronously
            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 GeneratePdfAsync: {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
			Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("Sample.pdf")).ConfigureAwait(False)
			' Extract text from PDF asynchronously
			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 GeneratePdfAsync: {ex.Message}")
		End Try
	End Function
End Class

在上述代码中，`*ConfigureAwait(错误)` 用于从大型 PDF 文件中提取所有文本的大型耗时任务，在我们的案例中，该文件长达 200 多页。

导入和设置： 代码顶部的第一节专门用于导入必要的库和命名空间。要使用 IronPDF 库，您需要确保您已安装了 **using IronPdf**\ 。
类和主要方法： `class Program` 定义了包含本项目主要应用代码的类。 `static 异步任务主程序(字符串[]参数)` 是应用程序的入口。在这里，我们将其标记为 async，这样我们的异步操作就可以在其中运行。然后，我们使用 await LongPdfTask() 异步调用 LongPdfTask 方法。
尝试块： 我已将LongPdfTask方法中的代码封装在一个try-catch块中，以便优雅地处理任何意外异常。
- **PdfDocument PDF = await Task.Run(()=> PdfDocument.FromFile("样本.pdf")).配置等待(错误)本项目可分为三个不同部分：
  - PdfDocument.FromFile("样本.pdf"): 本部分将指定的 PDF 文件同步加载到一个IronPdf.PdfDocument反对
  - 等待任务运行(()=> ...): 在单独的线程上运行 PDF 加载操作，以避免阻塞主线程。因此，这是一项异步工作。
.配置等待(错误): 避免捕捉当前上下文，从而提高性能并减少死锁。
string text = await Task.Run(()=> pdf.ExtractAllText()).配置等待(错误): 该项目将运行IronPDF 文本提取方法、提取所有文本(). 再次，等待 Task.Run(()=> ...) 用于在单独的线程上异步运行此操作。
等待任务运行(()=> File.WriteAllText("提取的文本.txt", 文本)).配置等待(错误)我们将再次使用 await Task** 方法异步将提取的文本写入 .txt 文件。

之前

C# ConfigureAwait（如何为开发人员工作）：图 2

输出

C# ConfigureAwait（如何为开发人员工作）：图 3

在 .NET 应用程序中使用 ConfigureAwait 的最佳实践

何时使用 ConfigureAwait(真) 与 ConfigureAwait(错误)

配置等待(错误)当您在库代码或后台处理中工作时，不需要保留同步上下文，这时最好使用 。通常，这是针对性能至关重要的服务器端代码。使用 ConfigureAwait(错误) 这意味着当等待**操作完成后，续程不一定在启动异步操作的同一线程上运行。

在处理 PDF 时，实施 *ConfigureAwait(错误)在运行多个 PDF 处理任务时，*可帮助最大限度地提高性能，避免出现与上下文切换相关的瓶颈。在处理大量 PDF 文件时，它还能帮助应用程序保持流畅运行；在控制台应用程序或后台服务中工作时，上下文切换可能没有必要，它也能帮助保持效率。

配置等待(真) 最适合用于用户界面、代码的任何单元测试或 ASP.NET 应用程序，在这些应用程序中，延续必须在同一上下文中运行，但如果使用不当，可能会导致死锁。例如，如果您正在更新用户界面或访问 httpcontext). 配置等待(真)是默认行为，也可写成ConfigureAwait。

当与 PDF 处理任务一起使用时，它在以下情况下尤其有用，例如您的 PDF 处理代码与用户界面紧密集成的情况(当使用 WPF、WinForms 等用户界面应用程序时)例如，在显示进度时，您需要捕获同步上下文，以确保这些更新在用户界面线程上进行。在处理线程敏感的操作时，由于线程亲和性的要求，这些操作必须在特定的线程上执行，这也有利于翻译。

在异步 IronPDF 操作中处理异常

在异步编程中处理异常是需要牢记的一个重要方面，需要仔细考虑，未处理的异常可能会终止应用程序。在异步代码中使用 try-catch 块是优雅地处理任何意外异常的好方法。

例如

public async Task SafeGeneratePdfAsync()
{
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);
        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();
        PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(false);
        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()
		Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Error Handling</h1>").ConfigureAwait(False)
		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 时的延续任务(错误)\如果使用Task.ContinueWith，则可以使用Task.Exception属性处理异常。

如何编写代码的示例如下

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

为什么选择 IronPDF 满足您的 PDF 处理需求？

IronPDF 的主要功能和优势

C# ConfigureAwait（如何为开发人员工作）：图 4

IronPDF 是一个功能强大的 C# PDF 库，可为您的所有 PDF 相关任务提供丰富的功能。 IronPDF 完全支持 .NET8、7、6、.NET Core、Standard 和 Framework，并能在 Windows、Linux、Mac、Docker、Azure 和 AWS 等一系列应用程序环境中运行，无论您喜欢什么环境，都能最大限度地利用 IronPDF。

使用 IronPDF，您可以从各种文件和数据类型生成 PDF；包括HTML 文件, HTML 字符串, 网址, 图像, DOCX和RTF在翻译工作中，我们经常需要在短短几行代码中! 它可以处理 PDF 文档的格式，应用自定义水印, 合并和分割 PDF, 处理PDF 加密和安全性，以及更多。

IronPDF 对异步编程的支持

IronPDF 为其许多操作提供异步方法，允许开发人员无缝利用异步/等待模式。这种支持确保 IronPDF 可以集成到性能关键型应用程序中，而不会牺牲响应速度，使其成为在异步环境中工作的开发人员处理 PDF 相关任务的宝贵 PDF 工具。

许可

如果您想亲自试用 IronPdf 并探索其广泛的功能，您可以通过其免费试用期限。 IronPDF 的安装快捷简便，您很快就能在 PDF 项目中使用 IronPDF。想继续使用它并利用其强大的功能来提升您的 PDF 水平吗？许可证从仅 $749 起，提供慷慨的30天退款保证、整整一年的产品支持和更新，并以永久许可证的形式提供。(因此没有烦人的经常性费用!)

C# ConfigureAwait（如何为开发人员工作）：图 5

示例：使用 ConfigureAwait 和 IronPDF 生成 PDF

为了异步生成 PDF，我们将使用 IronPDF 执行渲染 HTML 文件的代码，并保存结果，同时使用 ConfigureAwait(错误)确保续篇不会不必要地切换回原始同步上下文。

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }
    static async Task<string> CreateInvoicePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);
            return filePath;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

using IronPdf;
using System.Threading.Tasks;
using System.IO;
using System;
class program
{
    public static async Task Main(string[] args)
    {
        await CreateInvoicePdfAsync();
    }
    static async Task<string> CreateInvoicePdfAsync()
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        try
        {
            var pdf = await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(false);
            await Task.Run(() => pdf.SaveAs("invoice.pdf")).ConfigureAwait(false);
            return filePath;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
            return null;
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks
Imports System.IO
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)
		Dim renderer As New ChromePdfRenderer()
		Try
			Dim pdf = Await renderer.RenderHtmlFileAsPdfAsync("example.html").ConfigureAwait(False)
			Await Task.Run(Function() pdf.SaveAs("invoice.pdf")).ConfigureAwait(False)
			Return filePath
		Catch ex As Exception
			Console.WriteLine($"Error generating PDF: {ex.Message}")
			Return Nothing
		End Try
	End Function
End Class

在此示例中，我们使用了我们创建的异步方法，static async TaskCreateInvoicePdfAsync()，从以下文件提供的 HTML 文件中生成 PDF 发票RenderHtmlFileAsPdfAsync方法。我们使用了 ConfigureAwait(错误)防止在原始同步上下文中继续执行这项任务，提高我们非用户界面应用程序的性能。

我们还实现了 await Task.Run())=> ...) 方法再次异步运行操作。最后，我们使用 pdf.SaveAs 方法将新生成的 PDF 文件保存为 "invoice.pdf"。 CreateInvoicePdfAsync 中的全部代码() 方法已封装在 try-catch 块中，以处理任何意外异常。

HTML 文件

C# ConfigureAwait（如何为开发人员工作）：图 6

输出

C# ConfigureAwait（如何为开发人员工作）：图 7

如您所见，我们成功地将 HTML 文件异步生成了 PDF，并为我们创建了一个清晰、高质量的 PDF 文件。

结论

异步编程对于构建反应灵敏、高效的 .NET 应用程序和使用 Node.js 必不可少。配置等待正确地使用这些工具可以帮助您实现最佳性能，尤其是在编写应用程序级代码时。在使用IronPDF该翻译必须在保持技术准确性的同时，解释这些开发人员工具的功能和优点。(错误)PDF处理任务确保您的PDF处理任务不会阻塞主线程，从而提高应用程序的整体响应速度。通过了解何时以及如何使用 ConfigureAwait，您可以使 IronPDF PDF 处理任务更强大、性能更友好。

现在，您可以在异步编程中熟练使用 ConfigureAwait 和 IronPDF，还等什么？立即试用 IronPDF，了解它如何改善您的 PDF 相关项目! 如果您想更多地了解 IronPdf 作为强大的通用库代码所具有的广泛功能，请务必查看其便捷的操作指南. 或者，如果您想了解更多有关 IronPDF 与异步编程方法并用的信息，或者只是想了解更多有关 IronPDF 的总体信息，请查看我们的博文. 如果您正在寻找更多异步生成 PDF 的示例，请查看我们的C# 等待几秒钟或我们在C# Task.Run.

雷根·彭

立即与工程团队聊天

软件工程师

Regan毕业于雷丁大学，拥有电子工程学士学位。在加入Iron Software之前，他的前工作职位要求他专注于单一任务；他在Iron Software最喜欢的是能进行多种工作，无论是增加销售价值、技术支持、产品开发还是营销。他喜欢了解开发人员如何使用Iron Software的库，并利用这些知识不断改进文档和开发产品。

< 前一页
Azure 表（如何为开发人员工作）

下一步 >
C# 可空类型（如何为开发人员工作）