Comment : publier des événements conformes aux indications du .NET Framework (Guide de programmation C#)

Article
06/10/2015

La procédure suivante montre comment ajouter des événements qui suivent le modèle standard du .NET Framework à vos classes et structures. Tous les événements de la bibliothèque de classes du .NET Framework sont basés sur le délégué EventHandler, défini comme suit :

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

Notes

Le .NET Framework 2,0 introduit une version générique de ce délégué, EventHandler.Les exemples suivants montrent comment utiliser les deux versions.

Bien que les événements des classes que vous définissez puissent être basés sur tout type délégué valide, y compris les délégués qui retournent une valeur, il est généralement recommandé de baser les événements sur le modèle du .NET Framework en utilisant EventHandler, comme illustré dans l'exemple suivant.

Pour publier les événements basés sur le modèle EventHandler

(Passez directement à l'étape 3a si vous n'avez pas besoin d'envoyer des données personnalisées avec votre événement.) Déclarez la classe pour vos données personnalisées avec une portée visible des classes d'éditeur et d'abonné. Ajoutez ensuite les membres requis pour conserver vos données d'événement personnalisées. Dans cet exemple, une simple chaîne est retournée.
```
public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        msg = s;
    }
    private string msg;
    public string Message
    {
        get { return msg; }
    } 
}
```
(Ignorez cette étape si vous utilisez la version générique de EventHandler.) Déclarez un délégué dans votre classe d'édition. Donnez-lui un nom qui se termine par EventHandler. Le deuxième paramètre spécifie votre type EventArgs personnalisé.
```
public delegate void CustomEventHandler(object sender, CustomEventArgs a);
```
Déclarez l'événement dans votre classe d'édition en utilisant l'une des étapes ci-après.
1. Si vous n'avez aucune classe EventArgs personnalisée, votre type d'événement est le délégué EventHandler non générique. Vous n'avez pas besoin de déclarer le délégué parce qu'il l'est déjà dans l'espace de noms System inclus lors de la création de votre projet C# : Ajoutez le code suivant à votre classe d'éditeur.
```
public event EventHandler RaiseCustomEvent;
```
2. Si vous utilisez la version non générique de EventHandler et que vous avez une classe personnalisée dérivée de EventArgs, déclarez votre événement à l'intérieur de votre classe d'édition et utilisez le délégué de l'étape 2 comme type.
```
public event CustomEventHandler RaiseCustomEvent;
```
3. Si vous utilisez la version générique, vous n'avez pas besoin d'un délégué personnalisé. À la place, dans votre classe d'édition, vous spécifiez votre type d'événement comme EventHandler<CustomEventArgs>, en substituant le nom de votre propre classe entre les signes « inférieur à » et « supérieur à ».
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Exemple

L'exemple suivant illustre les étapes précédentes en utilisant une classe EventArgs personnalisée et EventHandler comme type d'événement.

namespace DotNetEvents
{
    using System;
    using System.Collections.Generic;

    // Define a class to hold custom event info 
    public class CustomEventArgs : EventArgs
    {
        public CustomEventArgs(string s)
        {
            message = s;
        }
        private string message;

        public string Message
        {
            get { return message; }
            set { message = value; }
        }
    }

    // Class that publishes an event 
    class Publisher
    {

        // Declare the event using EventHandler<T> 
        public event EventHandler<CustomEventArgs> RaiseCustomEvent;

        public void DoSomething()
        {
            // Write some code that does something useful here 
            // then raise the event. You can also raise an event 
            // before you execute a block of code.
            OnRaiseCustomEvent(new CustomEventArgs("Did something"));

        }

        // Wrap event invocations inside a protected virtual method 
        // to allow derived classes to override the event invocation behavior 
        protected virtual void OnRaiseCustomEvent(CustomEventArgs e)
        {
            // Make a temporary copy of the event to avoid possibility of 
            // a race condition if the last subscriber unsubscribes 
            // immediately after the null check and before the event is raised.
            EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

            // Event will be null if there are no subscribers 
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += String.Format(" at {0}", DateTime.Now.ToString());

                // Use the () operator to raise the event.
                handler(this, e);
            }
        }
    }

    //Class that subscribes to an event 
    class Subscriber
    {
        private string id;
        public Subscriber(string ID, Publisher pub)
        {
            id = ID;
            // Subscribe to the event using C# 2.0 syntax
            pub.RaiseCustomEvent += HandleCustomEvent;
        }

        // Define what actions to take when the event is raised. 
        void HandleCustomEvent(object sender, CustomEventArgs e)
        {
            Console.WriteLine(id + " received this message: {0}", e.Message);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            Subscriber sub1 = new Subscriber("sub1", pub);
            Subscriber sub2 = new Subscriber("sub2", pub);

            // Call the method that raises the event.
            pub.DoSomething();

            // Keep the console window open
            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();

        }
    }
}

Voir aussi

Référence

Événements (Guide de programmation C#)

Délégués (guide de programmation C#)

Delegate

Concepts

Guide de programmation C#

Partager via