C# Events (How it Works for Developers)

1. Publisher Class

The publisher class is the source of the event. It is responsible for declaring the event and raising it when a specific action or condition occurs. This process typically involves an event handler method to determine when the event occurs. The publisher also uses an event delegate to define the signature of the methods that can handle the event. For example, in a graphical user interface (GUI), a button control acts as the publisher when it raises a "Click" event.

2. Subscriber Class

The subscriber class listens for events and reacts to them. A subscriber registers its interest in an event by attaching an event handling method to the event. When the publisher raises the event, the subscriber’s event handler method executes. A single event can have multiple subscribers, each responding differently when the event happens.

3. Delegates

Delegates are the foundation of events in C#. They are type-safe pointers to methods and define the contract that all event handlers must follow. Delegates ensure that only methods with a specific signature can handle the event, providing a consistent and error-free event-handling mechanism.

4. Event Handlers

Event handlers are methods in the subscriber class that are executed when an event is triggered. They contain the logic to handle the event, such as updating the UI, logging data, or performing calculations. The signature of an event handler must match the delegate type associated with the event. Additionally, other classes can use event handlers to react to shared events. It makes it easier to implement events in a modular and reusable way.

5. Event Data

In many cases, events need to convey additional information to subscribers. This is achieved using event data classes, which are derived from the base EventArgs class. The event data contains specific details about the event, such as a message, status, or other relevant information.

Step 1: Declare a Delegate

Delegates define the method signature for event handlers. In this example, we create a delegate to represent the event handler with two parameters: object sender and EventArgs e.

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

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

Step 2: Declare an Event

Events are declared using the event keyword and are based on the delegate type. Here’s an example:

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

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

Step 3: Raise the Event

The event is raised by calling the delegate and passing the necessary parameters.

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

Step 4: Subscribe to the Event

Subscribers register event handlers using the += operator:

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.

Step 5: Handle the Event

An event handler is a method in the subscriber class that matches the delegate signature:

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

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

How Does IronPDF Fit?

IronPDF allows you to generate, modify, and secure PDFs, and integrating it with events can make your application more interactive. For instance:

• Progress Tracking: Notify subscribers about the percentage of completion when generating a large PDF report.
• Error Handling: Trigger an event if an issue arises during PDF rendering or saving.
• Custom Actions: Execute custom logic, like logging or UI updates, after specific PDF operations.

Example: Generating a PDF with Event Notifications

Here’s a simple example to demonstrate using IronPDF with events:

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}%");
    }
}