Un gestionnaire d'événements a-t-il déjà été ajouté?

Existe-t-il un moyen de savoir si un gestionnaire d'événements a été ajouté à un objet? Je sérialise une liste d'objets dans / hors état de session afin que nous puissions utiliser l'état de session basé sur SQL ... Lorsqu'un objet de la liste a une propriété modifiée, il doit être marqué, ce que le gestionnaire d'événements a pris en charge correctement avant . Cependant, maintenant, lorsque les objets sont désérialisés, il n'obtient pas le gestionnaire d'événements.

Dans un accès de gêne légère, je viens d'ajouter le gestionnaire d'événements à la propriété Get qui accède à l'objet. Il est appelé maintenant, ce qui est génial, sauf qu'il est appelé 5 fois, donc je pense que le gestionnaire continue d'être ajouté à chaque fois que l'objet est accédé.

C'est vraiment assez sûr pour être ignoré, mais je préfère le rendre beaucoup plus propre en vérifiant si le gestionnaire a déjà été ajouté, donc je ne le fais qu'une seule fois.

Est-ce possible?

EDIT: Je n'ai pas nécessairement un contrôle total sur les gestionnaires d'événements ajoutés, donc la simple vérification de null n'est pas suffisante.

De l'extérieur de la classe de définition, comme @Telos le mentionne, vous ne pouvez utiliser EventHandler que sur le côté gauche de a +=ou a -=. Donc, si vous avez la possibilité de modifier la classe de définition, vous pouvez fournir une méthode pour effectuer la vérification en vérifiant si le gestionnaire d'événements est null- si tel est le cas, aucun gestionnaire d'événements n'a été ajouté. Sinon, alors peut-être et vous pouvez parcourir les valeurs dans Delegate.GetInvocationList . Si l'un est égal au délégué que vous souhaitez ajouter en tant que gestionnaire d'événements, vous savez qu'il est là.

public bool IsEventHandlerRegistered(Delegate prospectiveHandler)
{   
    if ( this.EventHandler != null )
    {
        foreach ( Delegate existingHandler in this.EventHandler.GetInvocationList() )
        {
            if ( existingHandler == prospectiveHandler )
            {
                return true;
            }
        }
    }
    return false;
}

Et cela pourrait facilement être modifié pour devenir "ajouter le gestionnaire s'il n'y est pas". Si vous n'avez pas accès aux entrailles de la classe qui expose l'événement, vous devrez peut-être explorer -=et +=, comme suggéré par @Lou Franco.

Cependant, vous feriez peut-être mieux de réexaminer la manière dont vous mettez en service et désactivez ces objets, pour voir si vous ne pouvez pas trouver un moyen de suivre ces informations vous-même.

Je suis récemment arrivé à une situation similaire où je devais enregistrer un gestionnaire pour un événement une seule fois. J'ai trouvé que vous pouvez d'abord vous désinscrire en toute sécurité, puis vous réinscrire, même si le gestionnaire n'est pas du tout enregistré:

myClass.MyEvent -= MyHandler;
myClass.MyEvent += MyHandler;

Notez que faire cela à chaque fois que vous enregistrez votre gestionnaire garantira que votre gestionnaire n'est enregistré qu'une seule fois. Cela me semble être une très bonne pratique :)

S'il s'agit du seul gestionnaire, vous pouvez vérifier si l'événement est nul, sinon, le gestionnaire a été ajouté.

Je pense que vous pouvez appeler en toute sécurité - = sur l'événement avec votre gestionnaire même s'il n'est pas ajouté (sinon, vous pouvez l'attraper) - pour vous assurer qu'il n'est pas là avant de l'ajouter.

Cet exemple montre comment utiliser la méthode GetInvocationList () pour récupérer des délégués à tous les gestionnaires qui ont été ajoutés. Si vous cherchez à voir si un gestionnaire (fonction) spécifique a été ajouté, vous pouvez utiliser array.

public class MyClass
{
  event Action MyEvent;
}

...

MyClass myClass = new MyClass();
myClass.MyEvent += SomeFunction;

...

Action[] handlers = myClass.MyEvent.GetInvocationList(); //this will be an array of 1 in this example

Console.WriteLine(handlers[0].Method.Name);//prints the name of the method

Vous pouvez examiner diverses propriétés de la propriété Method du délégué pour voir si une fonction spécifique a été ajoutée.

Si vous cherchez à voir s'il n'y en a qu'un seul attaché, vous pouvez simplement tester null.

Si je comprends bien votre problème, vous pouvez avoir des problèmes plus importants. Vous avez dit que d'autres objets peuvent souscrire à ces événements. Lorsque l'objet est sérialisé et désérialisé, les autres objets (ceux dont vous n'avez pas le contrôle) perdront leurs gestionnaires d'événements.

Si cela ne vous inquiète pas, garder une référence à votre gestionnaire d'événements devrait suffire. Si vous êtes préoccupé par les effets secondaires d'autres objets perdant leurs gestionnaires d'événements, vous voudrez peut-être repenser votre stratégie de mise en cache.

Je suis d'accord avec la réponse d'alf, mais il y a peu de modifications à y apporter, à utiliser,

           try
            {
                control_name.Click -= event_Click;
                main_browser.Document.Click += Document_Click;
            }
            catch(Exception exce)
            {
                main_browser.Document.Click += Document_Click;
            }

La seule façon qui a fonctionné pour moi est de créer une variable booléenne que j'ai définie sur true lorsque j'ajoute l'événement. Alors je demande: si la variable est fausse, j'ajoute l'événement.

bool alreadyAdded = false;

Cette variable peut être globale.

if(!alreadyAdded)
{
    myClass.MyEvent += MyHandler;
    alreadyAdded = true;
}

EventHandler.GetInvocationList().Length > 0