Em C#, os eventos são uma parte fundamental da programação orientada a eventos. Eles permitem que os objetos se comuniquem e notifiquem outros quando algo de interesse acontece. Neste guia, exploraremos eventos e como declará-los e utilizá-los. Vamos analisar passo a passo para garantir uma compreensão clara. Também exploraremos o IronPDF para operações com PDFs em aplicações C#.

O que são eventos em C#?

Em C#, os eventos permitem a comunicação entre objetos. Quando um evento é acionado, outros objetos podem responder a ele. Os eventos dependem de delegados, que atuam como ponteiros com tipagem estática para métodos. Um tipo de delegado de evento define a assinatura dos métodos que podem lidar com o evento público, garantindo consistência no tratamento dos dados do evento.

Componentes Essenciais dos Eventos

Para compreender plenamente os eventos, vamos analisar seus principais componentes:

1. Classe de Editora

A classe editora é a fonte do evento. É responsável por declarar o evento e acioná-lo quando uma ação ou condição específica ocorre. Normalmente, esse processo envolve um método de tratamento de eventos para determinar quando o evento ocorre. O editor também utiliza um delegado de evento para definir a assinatura dos métodos que podem lidar com o evento. Por exemplo, em uma interface gráfica do usuário (GUI), um controle de botão atua como o publicador quando aciona um evento "Click".

2. Classe de Assinantes

A classe de assinante fica à escuta de eventos e reage a eles. Um assinante registra seu interesse em um evento anexando um método de tratamento de eventos ao evento. Quando o editor dispara o evento, o método de tratamento de eventos do assinante é executado. Um único evento pode ter vários assinantes, cada um respondendo de maneira diferente quando o evento ocorre.

3. Delegados

Os delegados são a base dos eventos em C#. São ponteiros com tipagem estática para métodos e definem o contrato que todos os manipuladores de eventos devem seguir. Os delegados garantem que apenas métodos com uma assinatura específica possam lidar com o evento, fornecendo um mecanismo de tratamento de eventos consistente e livre de erros.

4. Manipuladores de Eventos

Os manipuladores de eventos são métodos da classe assinante que são executados quando um evento é acionado. Elas contêm a lógica para lidar com o evento, como atualizar a interface do usuário, registrar dados ou realizar cálculos. A assinatura de um manipulador de eventos deve corresponder ao tipo de delegado associado ao evento. Além disso, outras classes podem usar manipuladores de eventos para reagir a eventos compartilhados. Isso facilita a implementação de eventos de forma modular e reutilizável.

5. Dados do evento

Em muitos casos, os eventos precisam transmitir informações adicionais aos assinantes. Isso é conseguido usando classes de dados de eventos , que são derivadas da classe base EventArgs. Os dados do evento contêm detalhes específicos sobre o evento, como uma mensagem, status ou outras informações relevantes.

How to Declare and Use Events in C#

Passo 1: Declarar um Delegado

Os delegados definem a assinatura do método para os manipuladores de eventos. Neste exemplo, criamos um delegado para representar o manipulador de eventos com dois parâmetros: object sender e EventArgs e.

public delegate void MyEventHandler(object sender, EventArgs e);

public delegate void MyEventHandler(object sender, EventArgs e);

Public Delegate Sub MyEventHandler(ByVal sender As Object, ByVal e As EventArgs)

Public Delegate Sub MyEventHandler(ByVal sender As Object, ByVal e As EventArgs)

Etapa 2: Declarar um evento

Eventos são declarados usando a palavra-chave event e são baseados no tipo de delegado. Eis um exemplo:

public class Publisher
{
    public event MyEventHandler Notify; // Declare the event.
}

public class Publisher
{
    public event MyEventHandler Notify; // Declare the event.
}

Public Class Publisher
	Public Event Notify As MyEventHandler ' Declare the event.
End Class

Public Class Publisher
	Public Event Notify As MyEventHandler ' Declare the event.
End Class

Etapa 3: Promover o evento

O evento é acionado chamando o delegado e passando os parâmetros necessários.

public void TriggerEvent()
{
    if (Notify != null) // Check if there are subscribers.
    {
        Notify(this, EventArgs.Empty); // Raise the event.
    }
}

public void TriggerEvent()
{
    if (Notify != null) // Check if there are subscribers.
    {
        Notify(this, EventArgs.Empty); // Raise the event.
    }
}

Public Sub TriggerEvent()
	If Notify IsNot Nothing Then ' Check if there are subscribers.
		Notify(Me, EventArgs.Empty) ' Raise the event.
	End If
End Sub

Public Sub TriggerEvent()
	If Notify IsNot Nothing Then ' Check if there are subscribers.
		Notify(Me, EventArgs.Empty) ' Raise the event.
	End If
End Sub

Passo 4: Inscreva-se no evento

Assinantes registram manipuladores de eventos usando o operador +=:

Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();
publisher.Notify += subscriber.OnNotify; // Subscribe to the event.

Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();
publisher.Notify += subscriber.OnNotify; // Subscribe to the event.

Dim publisher As New Publisher()
Dim subscriber As New Subscriber()
publisher.Notify += subscriber.OnNotify ' Subscribe to the event.

Dim publisher As New Publisher()
Dim subscriber As New Subscriber()
publisher.Notify += subscriber.OnNotify ' Subscribe to the event.

Etapa 5: Lidar com o evento

Um manipulador de eventos é um método na classe assinante que corresponde à assinatura do delegado:

public void OnNotify(object sender, EventArgs e)
{
    Console.WriteLine("Event received!");
}

public void OnNotify(object sender, EventArgs e)
{
    Console.WriteLine("Event received!");
}

Public Sub OnNotify(ByVal sender As Object, ByVal e As EventArgs)
	Console.WriteLine("Event received!")
End Sub

Public Sub OnNotify(ByVal sender As Object, ByVal e As EventArgs)
	Console.WriteLine("Event received!")
End Sub

IronPDF: Biblioteca PDF em C#

IronPDF, uma biblioteca versátil para trabalhar com PDFs em .NET, integra-se perfeitamente com aplicativos C#. Combinado com eventos em C#, ele pode fornecer uma maneira dinâmica de lidar com cenários em tempo real, como atualizações de progresso, tratamento de erros ou notificações durante a geração ou manipulação de PDF. Vamos explorar essa relação de forma envolvente. Em C#, eventos são uma forma de sinalizar que algo aconteceu. Eles permitem que uma parte do seu programa notifique outras partes sobre ocorrências específicas, como um arquivo sendo processado, uma tarefa concluída ou um erro encontrado.

Como o IronPDF se encaixa?

O IronPDF permite gerar, modificar e proteger PDFs, e a integração com eventos pode tornar seu aplicativo mais interativo. Por exemplo:

• Acompanhamento do progresso: Notifique os assinantes sobre a porcentagem de conclusão ao gerar um relatório PDF extenso.
• Tratamento de erros: Aciona um evento se ocorrer um problema durante a renderização ou o salvamento do PDF.
• Ações personalizadas: Execute lógica personalizada, como registro de logs ou atualizações da interface do usuário, após operações específicas em PDFs.

Exemplo: Geração de um PDF com notificações de eventos

Aqui está um exemplo simples para demonstrar o uso do IronPDF com eventos:

using IronPdf;
using System;

// Program class
class Program
{
    // Define a custom event for progress updates
    public static event Action<int> ProgressUpdated;

    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;
        
        Console.WriteLine("Generating PDF...");
        GeneratePdf(); // Generate the PDF
    }

    // Method to generate PDF and trigger progress updates
    static void GeneratePdf()
    {
        try
        {
            var Renderer = new ChromePdfRenderer();
            for (int i = 0; i <= 100; i += 20)
            {
                // Simulate progress
                System.Threading.Thread.Sleep(500);
                ProgressUpdated?.Invoke(i); // Trigger event with progress value
            }
            // Generate a PDF
            var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>");
            PdfDocument.SaveAs("IronPDF/example.pdf");
            ProgressUpdated?.Invoke(100); // Final update
            Console.WriteLine("PDF generated successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Event handler to display progress
    static void DisplayProgress(int progress)
    {
        Console.WriteLine($"Progress: {progress}%");
    }
}

using IronPdf;
using System;

// Program class
class Program
{
    // Define a custom event for progress updates
    public static event Action<int> ProgressUpdated;

    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;
        
        Console.WriteLine("Generating PDF...");
        GeneratePdf(); // Generate the PDF
    }

    // Method to generate PDF and trigger progress updates
    static void GeneratePdf()
    {
        try
        {
            var Renderer = new ChromePdfRenderer();
            for (int i = 0; i <= 100; i += 20)
            {
                // Simulate progress
                System.Threading.Thread.Sleep(500);
                ProgressUpdated?.Invoke(i); // Trigger event with progress value
            }
            // Generate a PDF
            var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>");
            PdfDocument.SaveAs("IronPDF/example.pdf");
            ProgressUpdated?.Invoke(100); // Final update
            Console.WriteLine("PDF generated successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Event handler to display progress
    static void DisplayProgress(int progress)
    {
        Console.WriteLine($"Progress: {progress}%");
    }
}

Imports IronPdf
Imports System

' Program class
Class Program
    ' Define a custom event for progress updates
    Public Shared Event ProgressUpdated As Action(Of Integer)

    Public Shared Sub Main()
        License.LicenseKey = "License-Key"
        ' Subscribe to the ProgressUpdated event
        AddHandler ProgressUpdated, AddressOf DisplayProgress

        Console.WriteLine("Generating PDF...")
        GeneratePdf() ' Generate the PDF
    End Sub

    ' Method to generate PDF and trigger progress updates
    Shared Sub GeneratePdf()
        Try
            Dim Renderer = New ChromePdfRenderer()
            For i As Integer = 0 To 100 Step 20
                ' Simulate progress
                System.Threading.Thread.Sleep(500)
                RaiseEvent ProgressUpdated(i) ' Trigger event with progress value
            Next
            ' Generate a PDF
            Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>")
            PdfDocument.SaveAs("IronPDF/example.pdf")
            RaiseEvent ProgressUpdated(100) ' Final update
            Console.WriteLine("PDF generated successfully!")
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
        End Try
    End Sub

    ' Event handler to display progress
    Shared Sub DisplayProgress(progress As Integer)
        Console.WriteLine($"Progress: {progress}%")
    End Sub
End Class

Imports IronPdf
Imports System

' Program class
Class Program
    ' Define a custom event for progress updates
    Public Shared Event ProgressUpdated As Action(Of Integer)

    Public Shared Sub Main()
        License.LicenseKey = "License-Key"
        ' Subscribe to the ProgressUpdated event
        AddHandler ProgressUpdated, AddressOf DisplayProgress

        Console.WriteLine("Generating PDF...")
        GeneratePdf() ' Generate the PDF
    End Sub

    ' Method to generate PDF and trigger progress updates
    Shared Sub GeneratePdf()
        Try
            Dim Renderer = New ChromePdfRenderer()
            For i As Integer = 0 To 100 Step 20
                ' Simulate progress
                System.Threading.Thread.Sleep(500)
                RaiseEvent ProgressUpdated(i) ' Trigger event with progress value
            Next
            ' Generate a PDF
            Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>")
            PdfDocument.SaveAs("IronPDF/example.pdf")
            RaiseEvent ProgressUpdated(100) ' Final update
            Console.WriteLine("PDF generated successfully!")
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
        End Try
    End Sub

    ' Event handler to display progress
    Shared Sub DisplayProgress(progress As Integer)
        Console.WriteLine($"Progress: {progress}%")
    End Sub
End Class

Conclusão

Os eventos em C#, quando combinados com o IronPDF, criam um sistema poderoso para geração e gerenciamento dinâmico de PDFs. Os eventos oferecem uma maneira limpa e eficiente de lidar com operações de PDF de forma assíncrona, enquanto o IronPDF oferece funcionalidades robustas para criação, edição e manipulação de PDFs em plataformas .NET . O IronPDF oferece um período de teste gratuito para que você possa experimentar todos os recursos sem limitações. Licenças comerciais começam em $999 e proporcionam acesso à suíte completa de capacidades de geração e processamento de PDF.