A programação assíncrona tem ganhado importância na área de programação em C# para a criação de aplicações escaláveis ​​e responsivas. Com sua abundância de ferramentas e técnicas assíncronas, o AsyncEx é um pacote robusto que facilita a programação assíncrona em C#. Os desenvolvedores podem criar facilmente aplicativos complexos combinando o IronPDF, uma biblioteca C# para produzir, editar e processar documentos PDF, com outras bibliotecas.

Nito.AsyncEx fornece primitivas de coordenação, coleções assíncronas, primitivas de sincronização assíncrona e muitos outros recursos. Essas características permitem que os programadores criem código assíncrono que seja legível, gerenciável e eficiente.

Neste guia, veremos como usar o Nito.AsyncEx com o IronPDF para aproveitar a programação assíncrona em atividades que envolvem PDFs. Mostraremos como tirar o máximo proveito dessas duas bibliotecas para aprimorar sua experiência de desenvolvimento em C#, desde exemplos de uso simples até estratégias complexas.

O que é Nito.AsyncEx?

O pacote AC# chamado Nito.AsyncEx foi criado por Stephen Cleary para melhorar e agilizar a programação assíncrona no .NET Framework. Ele fornece um conjunto abrangente de utilitários e técnicas para superar os desafios associados à escrita de programas assíncronos. Nito.AsyncEx é uma biblioteca .NET que é usada principalmente para desenvolver um padrão assíncrono baseado em tarefas.

Nito.AsyncEx é uma biblioteca auxiliar valiosa para desenvolvedores C#, proporcionando integração perfeita de padrões assíncronos baseados em tarefas em seus projetos. Graças à sua sintaxe intuitiva, os desenvolvedores podem utilizar palavras-chave como await task e hold await task para gerenciar operações assíncronas de forma eficaz. Esta biblioteca .NET facilita operações assíncronas bloqueadas, garantindo a segurança de threads e prevenindo condições de corrida. Em resumo, o Nito.AsyncEx simplifica a programação assíncrona, permitindo que os desenvolvedores se concentrem na criação de aplicativos robustos e escaláveis.

Funcionalidades do Nito.AsyncEx

Primitivas com Coordenação Assíncrona:

O AsyncEx oferece versões de primitivas de sincronização comuns, como locks, semáforos, eventos de contagem regressiva e barreiras. Ao coordenar o acesso a recursos compartilhados em contextos assíncronos, essas técnicas ajudam os desenvolvedores a evitar problemas de condição de corrida e a garantir a segurança de threads.

Coleções Assíncronas:

Os tipos de coleção comuns, incluindo filas, pilhas e buffers, são implementados de forma assíncrona na biblioteca. Essas coleções assíncronas melhoram o desempenho e a escalabilidade dos fluxos de trabalho assíncronos, facilitando o processamento e a manipulação eficazes de dados assíncronos.

Nito é um fluxo assíncrono:

O AsyncEx fornece ferramentas para trabalhar com fluxos assíncronos, facilitando a integração de pipelines de processamento de dados assíncronos e atividades de E/S. Os desenvolvedores podem aumentar a capacidade de resposta e a eficiência das atividades com uso intensivo de E/S lendo ou escrevendo em fluxos assíncronos de forma assíncrona.

Organização de Tarefas:

Com a ajuda das ferramentas de agendamento da biblioteca, os desenvolvedores podem gerenciar o tempo e o método de ações assíncronas. Com o auxílio dessa funcionalidade, a execução de tarefas pode ser gerenciada com mais precisão, maximizando o uso de recursos e melhorando o desempenho do aplicativo.

Extensões e Metodologias Assíncronas:

Ao adicionar métodos e extensões assíncronas ao .NET Framework, o Nito.AsyncEx facilita o uso de padrões e processos de programação assíncrona padrão. Agora ficou mais simples para os desenvolvedores criar e depurar aplicativos assíncronos graças a esses aprimoramentos, que melhoram a legibilidade e a manutenção do código assíncrono.

Criar e configurar projeto

Os passos abaixo podem ser usados ​​para criar e configurar o Nito.AsyncEx em um projeto C#:

Instalar o Pacote Nito.AsyncEx

Utilizando a CLI do .NET ou o Gerenciador de Pacotes NuGet , adicione o pacote Nito.AsyncEx ao seu projeto. Usando o Console do Gerenciador de Pacotes ou um terminal, digite o seguinte comando para instalar o pacote:

Install-Package Nito.AsyncEx

Configurar o Projeto Nito.AsyncEx

Após instalar o pacote, você poderá usar o Nito.AsyncEx em seu projeto. Em qualquer lugar dos seus projetos C# onde você planeja usar a funcionalidade de Nito.AsyncEx, importe seu namespace:

using Nito.AsyncEx;

using Nito.AsyncEx;

Imports Nito.AsyncEx

Imports Nito.AsyncEx

Exemplo de código de uso de Nito.AsyncEx

Agora você pode usar em seu código a funcionalidade que o Nito.AsyncEx oferece. Por exemplo, você pode aprimorar e simplificar seus fluxos de trabalho de programação assíncrona utilizando primitivas de coordenação assíncrona, como locks e semáforos, coleções assíncronas, fluxos assíncronos e muito mais.

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an instance of AsyncLock
        var mutex = new AsyncLock();
        
        // It can be locked asynchronously using await
        using (await mutex.LockAsync())
        {
            // Code inside the lock
            Console.WriteLine("Inside the lock.");
            
            // Simulate some asynchronous operation
            await Task.Delay(1000); // Delay for 1 second
            
            Console.WriteLine("Lock released.");
        }
    }
}

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an instance of AsyncLock
        var mutex = new AsyncLock();
        
        // It can be locked asynchronously using await
        using (await mutex.LockAsync())
        {
            // Code inside the lock
            Console.WriteLine("Inside the lock.");
            
            // Simulate some asynchronous operation
            await Task.Delay(1000); // Delay for 1 second
            
            Console.WriteLine("Lock released.");
        }
    }
}

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx

Module Program
    Async Function Main(ByVal args As String()) As Task
        ' Create an instance of AsyncLock
        Dim mutex As New AsyncLock()
        
        ' It can be locked asynchronously using Await
        Using Await mutex.LockAsync()
            ' Code inside the lock
            Console.WriteLine("Inside the lock.")
            
            ' Simulate some asynchronous operation
            Await Task.Delay(1000) ' Delay for 1 second
            
            Console.WriteLine("Lock released.")
        End Using
    End Function
End Module

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx

Module Program
    Async Function Main(ByVal args As String()) As Task
        ' Create an instance of AsyncLock
        Dim mutex As New AsyncLock()
        
        ' It can be locked asynchronously using Await
        Using Await mutex.LockAsync()
            ' Code inside the lock
            Console.WriteLine("Inside the lock.")
            
            ' Simulate some asynchronous operation
            Await Task.Delay(1000) ' Delay for 1 second
            
            Console.WriteLine("Lock released.")
        End Using
    End Function
End Module

Para garantir que não haja erros de compilação, compile seu código C#. Em seguida, execute seu aplicativo para garantir que o Nito.AsyncEx esteja funcionando corretamente.

Esses procedimentos permitirão que você utilize a funcionalidade do Nito.AsyncEx para atividades de programação assíncrona, criando e configurando-o em um projeto C#.

Primeiros passos com o IronPDF

O que é o IronPDF?

IronPDF é uma biblioteca rica em recursos para trabalhar com documentos PDF em aplicações .NET . Com seu vasto conjunto de recursos, os usuários podem alterar documentos PDF preexistentes, adicionando, removendo ou reorganizando seções, bem como criar PDFs do zero ou a partir de conteúdo HTML. O IronPDF facilita o trabalho com PDFs em aplicações .NET , fornecendo aos desenvolvedores uma API poderosa para criar, editar e converter arquivos PDF.

Principais características do IronPDF

• Converter HTML para PDF: O IronPDF permite usar conteúdo HTML, como CSS e JavaScript, para criar documentos PDF de alta qualidade. Ao gerar PDFs a partir de páginas da web ou conteúdo dinâmico, esse recurso é particularmente útil.
• Modificação e aprimoramento de PDFs: O IronPDF oferece recursos de edição para documentos PDF preexistentes. Um PDF pode ter suas páginas extraídas, texto, imagens, marcas d'água ou comentários adicionados, e vários PDFs podem ser combinados em um único documento.
• Criando um PDF imediatamente: Você pode adicionar texto, imagens, formas e outros objetos a novos documentos PDF programaticamente usando a API do IronPDF. Isso permite a geração dinâmica de relatórios em PDF, faturas e outros documentos.
• Segurança de PDF: Ao adicionar segurança por senha e criptografar documentos PDF usando o IronPDF, você pode controlar o acesso e proteger dados importantes.
• Formulários PDF: Os usuários podem trabalhar com documentos PDF usando o IronPDF para criar e preencher formulários PDF e inserir dados nos campos do formulário.
• Trechos de texto: O IronPDF extrai o conteúdo de texto de documentos PDF para facilitar a busca, análise e manipulação de dados textuais.
• Conversão para formatos de imagem: Como o IronPDF pode converter documentos PDF para formatos de imagem populares, como PNG, JPEG e BMP, ele é adequado para situações em que imagens são necessárias em vez de PDFs.

Instale o IronPDF

Certifique-se de que ambas as bibliotecas foram adicionadas ao seu projeto antes de começar a usar Nito.AsyncEx em C# com IronPDF. Você pode usar a CLI do .NET ou o Gerenciador de Pacotes NuGet para adicionar o IronPDF ao seu projeto. O comando usado no console do Gerenciador de Pacotes NuGet é o seguinte:

Install-Package IronPdf

Integre IronPDF com Nito.AsyncEx

Digamos que você tenha um caso em que queira usar o IronPDF para gerar um documento PDF de forma assíncrona e o Nito.AsyncEx para gerenciar a concorrência. Vou dar um exemplo simples para ilustrar isso:

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;
using IronPdf;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an asynchronous lock
        AsyncLock asyncLock = new AsyncLock();
        
        // Use the lock to ensure only one thread is accessing IronPDF at a time
        using (await asyncLock.LockAsync())
        {
            // Generate the PDF document asynchronously
            await GeneratePdfAsync();
        }
    }

    static async Task GeneratePdfAsync()
    {
        // Create IronPDF Renderer
        var Renderer = new IronPdf.HtmlToPdf();
        
        // Create HTML content for the PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        
        // Convert HTML to PDF asynchronously
        var pdfDocument = await Renderer.RenderHtmlAsPdfAsync(htmlContent);
        
        // Save the PDF document
        pdfDocument.SaveAs("example.pdf");
    }
}

using System;
using System.Threading.Tasks;
using Nito.AsyncEx;
using IronPdf;

class Program
{
    static async Task Main(string[] args)
    {
        // Create an asynchronous lock
        AsyncLock asyncLock = new AsyncLock();
        
        // Use the lock to ensure only one thread is accessing IronPDF at a time
        using (await asyncLock.LockAsync())
        {
            // Generate the PDF document asynchronously
            await GeneratePdfAsync();
        }
    }

    static async Task GeneratePdfAsync()
    {
        // Create IronPDF Renderer
        var Renderer = new IronPdf.HtmlToPdf();
        
        // Create HTML content for the PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        
        // Convert HTML to PDF asynchronously
        var pdfDocument = await Renderer.RenderHtmlAsPdfAsync(htmlContent);
        
        // Save the PDF document
        pdfDocument.SaveAs("example.pdf");
    }
}

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx
Imports IronPdf

Module Program
    Async Function Main(args As String()) As Task
        ' Create an asynchronous lock
        Dim asyncLock As New AsyncLock()

        ' Use the lock to ensure only one thread is accessing IronPDF at a time
        Using Await asyncLock.LockAsync()
            ' Generate the PDF document asynchronously
            Await GeneratePdfAsync()
        End Using
    End Function

    Private Async Function GeneratePdfAsync() As Task
        ' Create IronPDF Renderer
        Dim Renderer As New IronPdf.HtmlToPdf()

        ' Create HTML content for the PDF
        Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"

        ' Convert HTML to PDF asynchronously
        Dim pdfDocument = Await Renderer.RenderHtmlAsPdfAsync(htmlContent)

        ' Save the PDF document
        pdfDocument.SaveAs("example.pdf")
    End Function
End Module

Imports System
Imports System.Threading.Tasks
Imports Nito.AsyncEx
Imports IronPdf

Module Program
    Async Function Main(args As String()) As Task
        ' Create an asynchronous lock
        Dim asyncLock As New AsyncLock()

        ' Use the lock to ensure only one thread is accessing IronPDF at a time
        Using Await asyncLock.LockAsync()
            ' Generate the PDF document asynchronously
            Await GeneratePdfAsync()
        End Using
    End Function

    Private Async Function GeneratePdfAsync() As Task
        ' Create IronPDF Renderer
        Dim Renderer As New IronPdf.HtmlToPdf()

        ' Create HTML content for the PDF
        Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"

        ' Convert HTML to PDF asynchronously
        Dim pdfDocument = Await Renderer.RenderHtmlAsPdfAsync(htmlContent)

        ' Save the PDF document
        pdfDocument.SaveAs("example.pdf")
    End Function
End Module

Neste código:

• Os namespaces exigidos por Nito.AsyncEx e IronPDF foram importados.
• Instanciamos um AsyncLock usando Nito.AsyncEx, e então o usamos para garantir acesso seguro a threads ao gerar PDFs.
• No método Main, adquirimos o bloqueio usando LockAsync() para garantir acesso exclusivo ao IronPDF. A geração do documento PDF é feita dentro do cadeado.
• A função GeneratePdfAsync demonstra como gerar um documento PDF de forma assíncrona usando o IronPDF. Ele converte conteúdo HTML em PDF e, em seguida, salva o documento no disco.

Saída

Conclusão

Em resumo, Nito.AsyncEx e IronPDF estão integrados em C#, combinando a força da programação assíncrona com recursos eficazes de produção de PDFs. Os desenvolvedores podem controlar a concorrência e sincronizar o acesso à funcionalidade de renderização do IronPDF usando as primitivas de coordenação assíncrona do Nito.AsyncEx, garantindo segurança de threads e consumo eficiente de recursos.

Com os recursos de renderização de HTML para PDF do IronPDF e o paradigma async/await do Nito.AsyncEx, os desenvolvedores podem criar aplicativos escaláveis ​​e responsivos que produzem documentos PDF de forma assíncrona. Essa combinação mantém a experiência do usuário ágil e, ao mesmo tempo, permite a criação eficaz de PDFs a partir de conteúdo HTML.

Em resumo, Nito.AsyncEx e IronPDF trabalham em conjunto para permitir que desenvolvedores C# criem aplicativos de alto desempenho que utilizam programação assíncrona e criação de PDFs, o que aumenta a produtividade e proporciona experiências de usuário incríveis.

A IronPDF pode oferecer documentação completa e fácil de usar para desenvolvedores, além de soluções de software de ponta para clientes e usuários finais, integrando as tecnologias IronPDF e Iron Software à sua pilha de desenvolvimento de aplicativos corporativos. Além disso, essa base sólida facilitará projetos, sistemas de back-end e aprimoramento de processos. Iron Software pricing starts at $999. A rica documentação dessas tecnologias, a ativa comunidade de desenvolvedores online e as frequentes atualizações fazem delas uma ótima opção para projetos de desenvolvimento de software contemporâneos.