Eventos em C# (Como funcionam para desenvolvedores)

1. Classe do Publicador

A classe do publicador é 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 publicador 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.

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)

Etapa 2: Declarar um evento

Os 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

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

Passo 4: Inscreva-se no evento

Os 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.

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

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
Friend 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 Me.ProgressUpdated, AddressOf DisplayProgress

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

	' Method to generate PDF and trigger progress updates
	Private 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)
			Next i
			' Generate a PDF
			Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>")
			PdfDocument.SaveAs("IronPDF/example.pdf")
			RaiseEvent ProgressUpdated(100)
			Console.WriteLine("PDF generated successfully!")
		Catch ex As Exception
			Console.WriteLine($"Error: {ex.Message}")
		End Try
	End Sub

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