C# Events (Comment ça fonctionne pour les développeurs)

1. Classe Émettrice

La classe émettrice est la source de l'événement. Elle est responsable de déclarer l'événement et de le déclencher lorsqu'une action ou condition spécifique se produit. Ce processus implique généralement une méthode de gestion d'événement pour déterminer quand l'événement se produit. L'émetteur utilise également un délégué d'événement pour définir la signature des méthodes pouvant gérer l'événement. Par exemple, dans une interface utilisateur graphique (GUI), un contrôle de bouton agit comme émetteur lorsqu'il déclenche un événement " Clic ".

2. Classe Abonnée

La classe abonnée écoute les événements et y réagit. Un abonné enregistre son intérêt pour un événement en attachant une méthode de gestion d'événement à l'événement. Lorsque l'émetteur déclenche l'événement, la méthode de gestion d'événement de l'abonné s'exécute. Un seul événement peut avoir plusieurs abonnés, chacun réagissant différemment lorsque l'événement survient.

3. Délégués

Les délégués sont la base des événements en C#. Ce sont des pointeurs typés vers des méthodes et définissent le contrat que tous les gestionnaires d'événements doivent suivre. Les délégués s'assurent que seules les méthodes avec une signature spécifique peuvent gérer l'événement, fournissant un mécanisme de gestion des événements cohérent et sans erreur.

4. Gestionnaires d'événements

Les gestionnaires d'événements sont des méthodes dans la classe abonnée qui sont exécutées lorsqu'un événement est déclenché. Ils contiennent la logique pour gérer l'événement, comme la mise à jour de l'interface utilisateur, la journalisation des données, ou l'exécution de calculs. La signature d'un gestionnaire d'événements doit correspondre au type de délégué associé à l'événement. De plus, d'autres classes peuvent utiliser des gestionnaires d'événements pour réagir à des événements partagés. Cela rend l'implémentation des événements plus simple, modulaire et réutilisable.

5. Données d'événement

Dans de nombreux cas, les événements doivent transmettre des informations supplémentaires aux abonnés. Cela est réalisé en utilisant des classes de données d'événement, qui sont dérivées de la classe de base EventArgs. Les données de l'événement contiennent des détails spécifiques concernant l'événement, comme un message, un statut, ou d'autres informations pertinentes.

Étape 1 : déclarer un délégué

Les délégués définissent la signature de méthode pour les gestionnaires d'événements. Dans cet exemple, nous créons un délégué pour représenter le gestionnaire d'événements avec deux paramètres : object sender et 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)

Étape 2 : déclarer un événement

Les événements sont déclarés à l'aide du mot-clé event et sont basés sur le type de délégué. Voici un exemple :

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

Étape 3 : déclencher l'événement

L'événement est déclenché en appelant le délégué et en passant les paramètres nécessaires.

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

Étape 4 : s'inscrire à l'événement

Les abonnés enregistrent les gestionnaires d'événements à l'aide de l'opérateur += :

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.

Étape 5 : gérer l'événement

Un gestionnaire d'événements est une méthode dans la classe abonnée qui correspond à la signature du délégué :

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

Comment IronPDF s'intègre-t-il ?

IronPDF vous permet de générer, modifier, et sécuriser des PDF, et l'intégrer avec des événements peut rendre votre application plus interactive. Par exemple :

• Suivi de l'avancement : Informer les abonnés du pourcentage d'achèvement lors de la génération d'un rapport PDF volumineux.
• Gestion des erreurs : Déclencher un événement en cas de problème lors du rendu ou de l'enregistrement d'un PDF.
• Actions personnalisées : Exécutez une logique personnalisée, comme la journalisation ou les mises à jour de l'interface utilisateur, après des opérations PDF spécifiques.

Exemple : générer un PDF avec des notifications d'événements

Voici un simple exemple pour démontrer l'utilisation d'IronPDF avec des événements :

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