Événements C# (Comment cela fonctionne pour les développeurs)

Événements en C#font une partie fondamentale de la programmation événementielle. Ils permettent aux objets de communiquer et d'informer les autres lorsqu'un événement intéressant se produit. Dans ce guide, nous allons explorer les événements et comment les déclarer et les utiliser. Décomposons-le étape par étape pour garantir une compréhension claire. Nous explorerons égalementIronPDFpour des opérations PDF dans des applications C#.

Qu'est-ce qu'un événement en C# ?

Les événements en C# permettent la communication entre les 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 sécurisés de type vers des 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, garantissant la cohérence dans la gestion des données d'événement.

Composants Principaux des Événements

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

1. Classe Publisher

La classe "publisher" est la source de l'événement. Il est responsable de déclarer l'événement et de le déclencher lorsqu'une action ou une condition spécifique se produit. Ce processus implique généralement une méthode de gestionnaire d'événements pour déterminer quand l'événement se produit. L'éditeur 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 le diffuseur lorsqu'il déclenche un événement "Click".

2. Classe Subscriber

La classe d'abonné écoute les événements et réagit à ceux-ci. 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'éditeur déclenche l'événement, la méthode du gestionnaire d'événements de l'abonné s'exécute. Un événement unique peut avoir plusieurs abonnés, chacun réagissant différemment lorsque l'événement se produit.

3. Délégués

Les délégués sont la base des événements en C#. Ce sont des pointeurs sécurisés de type vers des méthodes et définissent le contrat que tous les gestionnaires d'événements doivent suivre. Les délégués garantissent que seules les méthodes ayant une signature spécifique peuvent gérer l'événement, offrant ainsi 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 facilite l'implémentation des événements de manière 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. Ceci est réalisé en utilisant les classes de données d'événements, qui dérivent de la classe de base EventArgs. Les données de l'événement contiennent des détails spécifiques sur l'événement, tels qu'un message, un statut ou d'autres informations pertinentes.

Comment déclarer et utiliser des événements en 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)

É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 délégué. En 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'abonner à l'événement

Les abonnés enregistrent des 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.

É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

IronPDF : C&num ; Bibliothèque PDF

IronPDF, une bibliothèque polyvalente pour travailler avec les PDF dans .NET, s'intègre parfaitement aux applications C#. Combiné avec les événements en C#, il peut offrir une manière dynamique de gérer des scénarios en temps réel comme les mises à jour de progression, la gestion des erreurs ou les notifications pendantGénération PDFou manipulation. Explorons cette relation de manière engageante. En C#, les événements sont un moyen d'indiquer qu'un événement s'est produit. Ils permettent à une partie de votre programme de notifier d'autres parties à propos de certains événements spécifiques, comme le traitement d'un fichier, l'achèvement d'une tâche ou la rencontre d'une erreur.

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

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

• Suivi de l'avancement : Informer les abonnés du pourcentage de complétion lors de la génération d'un rapport PDF volumineux.
• Gestion des erreurs : Déclencher un événement si un problème survient lors du rendu ou de l'enregistrement du 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ération d'un PDF avec notifications d'événements

Voici un exemple simple 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
    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;
        Console.WriteLine("Generating PDF...");
        GeneratePdf();
    }
    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}");
        }
    }
    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
    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;
        Console.WriteLine("Generating PDF...");
        GeneratePdf();
    }
    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}");
        }
    }
    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 static void Main
	Public Shared Sub Main()
		License.LicenseKey = "License-Key"
		' Subscribe to the ProgressUpdated event
		AddHandler Me.ProgressUpdated, AddressOf DisplayProgress
		Console.WriteLine("Generating PDF...")
		GeneratePdf()
	End Sub
	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
	Private Shared Sub DisplayProgress(ByVal progress As Integer)
		Console.WriteLine($"Progress: {progress}%")
	End Sub
End Class

Conclusion

Les événements en C# combinés avec IronPDF créent un système puissant pour la génération et la gestion dynamique de PDF. Les événements offrent une méthode propre et efficace pour 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 les plateformes .NET. IronPDF offre un service deessai gratuittester toutes les fonctionnalités sans limitations. Les licences commerciales commencent à partir de 749 $ et offrent un accès à l'ensemble complet des fonctionnalités de génération et de traitement des PDF.