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

Article
01/07/2009

Mise à jour : novembre 2007

La procédure suivante montre comment ajouter des événements qui suivent le modèle standard du .NET Framework à vos propres 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);

Remarque :
Le .NET Framework 2.0 introduit une version générique de ce délégué, EventHandler<TEventArgs>. 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 votre classe avec une portée visible des classes d'éditeur et d'abonné et ajoutez 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<TEventArgs>.) 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 le déclarer parce qu'il l'est déjà dans l'espace de noms System inclus lors de la création de votre projet C# :
```
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 votre délégué comme type :
```
class Publisher
{
    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, 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 proposées ci-dessus en utilisant une classe EventArgs personnalisée et EventHandler<TEventArgs> 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

Concepts

Guide de programmation C#

Conception d'événements

Référence

Événements (Guide de programmation C#)

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

Delegate

Partager via