Utilisation

Program est abonné à l'évènement MonEvent.
Lorsque MaClasse lance l'évènement MonEvent, la méthode maClasse_MonEvent de Program sera exécutée.

class Program
{
    static void Main(string[] args)
    {
        var maClasse = new MaClasse();
        maClasse.MonEvent += new EventHandler<MonEventArgs>(maClasse_MonEvent);
        // délégué anonyme (_sender, _e) = (object sender, MonEventArgs e)
        maClasse.MonEvent += (_sender, _e) => { Console.WriteLine(_e.Message); };
        maClasse.LancerEvenement();
    }

    static void maClasse_MonEvent(object sender, MonEventArgs e)
    {
        Console.WriteLine(e.Message);
    }
}

public class MaClasse
{
    public event EventHandler<MonEventArgs> MonEvent;

    // permet au code extérieur à la classe de lancer l’événement.
    public void LancerEvenement()
    {
        OnMonEvent("message");
    }

    // déclarer cette méthode protected pour que les classes dérivées puissent lancer l’événement
    // et virtual pour que les classes dérivées puissent modifier le lancement de l’événement.
    protected virtual void OnMonEvent(string message)
    {
        // Nouvelle méthode avec l'opérateur conditionnel null
        MonEvent?.Invoke(this, new MonEventArgs() { Message = message });

        // Ancienne méthode
        // 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.
        var handler = MonEvent;
        if (handler != null)
        {
            handler(this, new MonEventArgs() { Message = message });
        }
    }
}

public class MonEventArgs : EventArgs
{
    public string Message { get; set; }
}

Héritage

Un événement n'est accessible que depuis sa classe, quelque soit son modificateur d'accès, car l'EventHandler est toujours déclaré private.

public event EventHandler MonEvent;
// la déclaration précédente correspond en fait à
private EventHandler monEventDelegate;
public event EventHandler MonEvent
{
    add { monEventDelegate += value; }
    remove { monEventDelegate -= value; }
}

MonEvent(this, EventArgs.Empty);
// l'appel précédent correspond en fait à
monEventDelegate(this, EventArgs.Empty);

Solution de contournement : utiliser une méthode protected qui encapsule le lancement de l’événement.

Supprimer tous les EventHandlers associés à un event

pour ce faire il faut intercepter l'ajout d'EventHandlers et les stocker en vue de la suppression.

private ArrayList _eventHandlersList = new ArrayList();

private EventHandler _monEventHandler;
public event EventHandler MonEvent
{
    add
    {
        _monEventHandler += value;
        // on intercepte l'ajout d'EventHandler et on en profite pour l'enregistrer dans _eventHandlersList
        _eventHandlersList.Add(value);
    }
    remove
    {
        _monEventHandler -= value;
        _eventHandlersList.Remove(value);
    }
}

public void RemoveAllEventHandlers()
{
    foreach (EventHandler eventHandler in _eventHandlersList)
    {
        _monEventHandler -= eventHandler;
    }
    delegates.Clear();
}

public void Méthode()
{
    MonEvent += new EventHandler(...);
    MonEvent += new EventHandler(...);

    // on supprime tous les EventHandler associés à MonEvent
    RemoveAllEventHandlers();
}

Event vs Delegate

L'Event est un wrapper autour de Delegate.
Event ne permet pas d'assignation direct d'un delegate, mais plutôt l'ajout de delegate.

var maClasse = new MaClasse();
// il n'est pas possible d'assigner directement un delegate à un event
maClasse.MonEvent = null;
// on peut juste ajouter un delegate à l'event
maClasse.MonEvent += (_sender, _e) => { /* ... */ };