Les événements en C# sont une partie fondamentale de la programmation orientée événement. Ils permettent aux objets de communiquer et de notifier les autres lorsque quelque chose d'intéressant se produit. Dans ce guide, nous explorerons les événements et comment les déclarer et les utiliser. Décomposons-le étape par étape pour assurer une compréhension claire. Nous explorerons également IronPDF pour les opérations PDF dans les applications C#.

Qu'est-ce que les événements en C# ?

Les événements en C# permettent la communication entre objets. Lorsqu'un événement est déclenché, d'autres objets peuvent y répondre. Les événements reposent sur des délégués, qui agissent comme des pointeurs typés aux méthodes. Un type de délégué d'événement définit la signature des méthodes pouvant gérer l'événement public, assurant la cohérence dans le traitement des données d'événement.

Composants de base des événements

Pour comprendre pleinement les événements, examinons leurs composants principaux :

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.

How to Declare and Use Events in C#

É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)

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 en utilisant le 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

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

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 en utilisant 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.

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

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

IronPDF : Bibliothèque PDF en C#

IronPDF, une bibliothèque polyvalente pour travailler avec des PDF en .NET, s'intègre parfaitement aux applications C#. Combiné avec les événements en C#, cela peut fournir une manière dynamique de gérer des scénarios en temps réel tels que des mises à jour de progression, la gestion d'erreurs, ou des notifications pendant la génération ou la manipulation de PDF. Explorons cette relation de manière engageante. En C#, les événements sont un moyen de signaler qu'un événement s'est produit. Ils permettent à une partie de votre programme de notifier d'autres parties à propos d'occurrences spécifiques, comme un fichier en cours de traitement, une tâche achevée ou une erreur rencontrée.

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

Conclusion

Les événements en C#, lorsqu'ils sont combinés avec IronPDF, créent un système puissant pour la génération et la gestion dynamiques de PDF. Les événements fournissent un moyen propre et efficace de gérer les opérations PDF de manière asynchrone, tandis qu'IronPDF offre des fonctionnalités robustes pour la création, l'édition et la manipulation de PDF sur toutes les plateformes .NET. IronPDF offre une version d'essai gratuite pour tester toutes les fonctionnalités sans limitations. Les licences commerciales commencent à $999 et donnent accès à l'ensemble complet des capacités de génération et de traitement de PDF.