Évitez les abonnements en double aux événements en C #

Question

Comment suggérez-vous le meilleur moyen d’éviter les doublons d’événements? si cette ligne de code s'exécute à deux endroits, l'événement sera exécuté deux fois. J'essaie d'éviter que des événements tiers ne s'abonnent deux fois.

theOBject.TheEvent += RunMyCode;

Je peux utiliser efficacement ce programme dans mon setter delegate ...

theOBject.TheEvent -= RunMyCode;
theOBject.TheEvent += RunMyCode;

mais est-ce la meilleure façon?

Answer 1

Je pense que le moyen le plus efficace consiste à transformer votre événement en propriété et à lui ajouter des verrous d'accès concurrentiels, comme dans ce Exemple :

private EventHandler _theEvent;
private object _eventLock = new object();
public event EventHandler TheEvent
{
    add
    {
        lock (_eventLock) 
        { 
            _theEvent -= value; 
            _theEvent += value; 
        }
    }
    remove
    {
        lock (_eventLock) 
        { 
           _theEvent -= value; 
        }
    }
}

Answer 2

J'ai déjà fait cela auparavant .... cela suppose qu'il est acceptable que le dernier abonné s'appelle ce qui s'appelle.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            MyObject my = new MyObject();
            my.Changed += new EventHandler(my_Changed);
            my.Changed += new EventHandler(my_Changed1);

            my.Update();
            Console.ReadLine();
        }

        static void my_Changed(object sender, EventArgs e)
        {
            Console.WriteLine("Hello");
        }
        static void my_Changed1(object sender, EventArgs e)
        {
            Console.WriteLine("Hello1");
        }
    }
    public class MyObject
    {
        public MyObject()
        {
        }
        private EventHandler ChangedEventHandler;
        public event EventHandler Changed
        {
            add
            {
                ChangedEventHandler = value;
            }
            remove
            {
                ChangedEventHandler -= value;
            }
        }
        public void Update()
        {
            OnChanged();
        }

        private void OnChanged()
        {
            if (ChangedEventHandler != null)
            {
                ChangedEventHandler(this, null);
            }
        }
    }
}

Answer 3

Votre code est-il multi-threadé? Le verrouillage des accès simultanés n’est nécessaire que lorsque son multi-threaded. Si ce n'est pas une surcharge.

En tant que tel, votre approche de désabonnement et d'abonnement est correcte.

Merci

Answer 4

Si vous possédez le source de la classe ofObject, vous avez accès à InvocationList de TheEvent. Vous pouvez implémenter votre propre accesseur add pour l'événement et vérifier avant d'ajouter.

Cependant, je pense que votre approche convient également.

Answer 5

J'utilise votre approche sauf un détail. Je pense que les événements doivent être abonnés lorsque vous créez une nouvelle instance d'abonné ou theObject, cela rend le code plus simple. Ainsi, tout ce dont vous avez besoin est simplement de surveiller attentivement la mise au rebut des objets appropriés (la solution à éliminer est une solution pratique pour cela).

Vous avez mentionné que vous utilisiez un événement tiers, ce qui signifie que vous ne pouvez pas fournir votre propre réalisation pour les méthodes d'ajout / suppression, comme vous en avez été informé. Mais dans vos propres classes avec vos propres événements, vous devez définir votre propre réalisation des méthodes d’ajout / suppression d’événement afin de résoudre votre problème.