Neste tutorial, vamos ensinar os conceitos de Action em C# , Func delegate e tópicos relacionados. Este guia foi desenvolvido para iniciantes e irá orientá-lo(a) pelos conceitos básicos, fornecer exemplos e explicar os principais termos relacionados à delegação de ações .

Vamos começar por entender o que são delegates em C#. Exploraremos a biblioteca IronPDF mais adiante neste artigo.

Entendendo Delegados em C#

Delegados são uma construção de programação que funciona como referência para métodos, definidos por um conjunto específico de parâmetros e um tipo de retorno, encapsulando funcionalidades como tipos de delegado predefinidos e permitindo que os métodos retornem valores.

Permite a passagem de métodos como argumentos. Essencialmente, um delegate serve como um ponteiro de função, apontando para o método que ele representa. Em C#, existem dois tipos de delegados predefinidos que são amplamente utilizados: Func e Action .

O que é um Delegado Func?

O delegado Func representa um método que pode ter um valor de retorno. O último parâmetro de tipo especifica o tipo de retorno, e os tipos precedentes especificam os parâmetros de entrada.

Por exemplo, uma função<int, int, string> Recebe dois parâmetros inteiros e retorna uma mensagem em formato de texto.

Delegados na prática: exemplos

Vamos analisar alguns exemplos para entender como os delegates Func e Action funcionam em C#.

Exemplo de um Delegado de Ação

Um delegado de ação, um tipo de delegado predefinido, é usado quando você deseja executar um método que não retorna um valor especificamente, concentrando-se, em vez disso, em operações. Eis um exemplo básico:

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Este código define um delegado Action, ilustrando o uso de um método anônimo, que recebe um único parâmetro de string e o imprime no console. O símbolo => é usado para definir uma expressão lambda, que é uma maneira concisa de escrever métodos anônimos.

Exemplo de um Delegado Func

Um delegado Func , que retorna um valor, pode ser usado da seguinte forma:

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

Este exemplo cria um delegado Func que recebe dois parâmetros inteiros e retorna a soma deles. A soma será exibida no console da seguinte forma:

Conceitos-chave

Métodos anônimos

Em C#, os métodos anônimos oferecem uma maneira de definir métodos embutidos sem um nome. Eles são frequentemente usados ​​com delegados para criar instâncias de delegados diretamente.

Expressões Lambda

Expressões lambda são uma forma abreviada de escrever métodos anônimos. Elas permitem que você escreva menos código, obtendo o mesmo resultado.

Delegado Genérico

Um delegado genérico pode funcionar com qualquer tipo de dado. Func e Action são exemplos de delegates genéricos, que oferecem mais flexibilidade ao permitir que você especifique os tipos de entrada e saída em tempo de execução.

Instância de Delegado

Uma instância de delegado é criada com a palavra-chave new ou simplesmente atribuindo um método que corresponda à assinatura do delegado.

Espaço de nomes do sistema

O namespace System no .NET contém tipos internos como Func e Action , que fazem parte da biblioteca de classes base.

Programação Assíncrona com Delegados

Delegados, incluindo Action e Func , são essenciais para o gerenciamento de tarefas assíncronas em C#. Elas permitem que os desenvolvedores encapsulem uma referência a um método que pode então ser executado de forma assíncrona. Isso significa que a thread principal do aplicativo pode iniciar uma tarefa e, em seguida, continuar com outros trabalhos até que a tarefa seja concluída.

Nesse ponto, um método de retorno de chamada, referenciado por um delegado, é invocado para lidar com o resultado. Esse padrão é vital para a criação de interfaces de usuário responsivas que permanecem interativas mesmo durante a execução de operações de longa duração.

Exemplo: Processamento assíncrono de arquivos

Considere uma aplicação que precisa processar um arquivo grande. O uso de um delegado Action em conjunto com padrões de programação assíncrona, como Task, pode melhorar significativamente o desempenho da aplicação:

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

Public Async Function ProcessFileAsync(filePath As String, onComplete As Action(Of String)) As Task
    ' Asynchronously read file content
    Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
    ' Process the file content here (omitted for brevity)

    ' Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.")
End Function

Public Async Function ProcessFileAsync(filePath As String, onComplete As Action(Of String)) As Task
    ' Asynchronously read file content
    Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
    ' Process the file content here (omitted for brevity)

    ' Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.")
End Function

Neste exemplo, File.ReadAllTextAsync é usado para ler o conteúdo do arquivo sem bloquear a thread principal. Após o processamento do arquivo, um delegado de ação chamado onComplete é invocado para notificar o chamador de que a operação foi concluída, permitindo ações adicionais, como atualizar a interface do usuário ou registrar os resultados.

Introdução ao IronPDF: Uma Biblioteca PDF C#

IronPDF é uma biblioteca PDF abrangente em C# projetada para desenvolvedores .NET criarem, editarem e manipularem arquivos PDF com facilidade. Ele se destaca por um mecanismo de renderização baseado no Chrome, garantindo PDFs com qualidade de pixel perfeita a partir de conteúdo HTML , CSS, JavaScript e imagens.

O IronPDF é compatível com uma ampla gama de frameworks e ambientes .NET , incluindo .NET Standard, .NET Framework e .NET Core, nas plataformas Windows, Linux e macOS.

Instalando o IronPDF

Para incorporar o IronPDF em seus projetos .NET , você pode usar o NuGet, que é o método mais simples. Basta abrir o Console do Gerenciador de Pacotes no Visual Studio e executar o seguinte comando:

Install-Package IronPdf

Este comando baixa e instala o pacote IronPDF , configurando seu projeto para começar a usar o IronPDF para geração e manipulação de PDFs.

Exemplo de código com Action Delegate

Aqui está um exemplo simples que demonstra como usar o IronPDF em conjunto com um delegado de ação para executar uma tarefa de geração de PDF:

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Este exemplo define um delegado de ação que recebe uma string de HTML e usa o IronPDF para renderizá-la em um documento PDF. O PDF gerado é então salvo no sistema de arquivos. Essa abordagem demonstra como os delegates podem ser usados ​​para encapsular a lógica de geração de PDFs, tornando seu código mais modular e flexível.

Licenciamento

A IronPDF oferece diversas opções de licenciamento para desenvolvedores , desde licenças individuais até contratos corporativos. Os preços para essas licenças começam a partir de $999.

Conclusão

A esta altura, você já deve ter uma compreensão básica dos delegates Action e Func em C#, além de como usar métodos anônimos e expressões lambda. Lembre-se: a prática é fundamental para dominar os conceitos de delegação. Tente criar seus próprios exemplos para definir, atribuir e invocar delegados.

Você pode explorar livremente os recursos do IronPDF com a versão de avaliação gratuita . Caso atenda aos requisitos do seu projeto, você pode garantir uma licença com preços iniciando em $999.