È già stato aggiunto un gestore eventi?

C'è un modo per dire se un gestore eventi è stato aggiunto a un oggetto? Sto serializzando un elenco di oggetti in / fuori dallo stato della sessione in modo da poter utilizzare lo stato della sessione basato su SQL ... Quando un oggetto nell'elenco ha una proprietà modificata, deve essere contrassegnato, che il gestore di eventi ha gestito correttamente prima . Tuttavia ora quando gli oggetti vengono deserializzati non ottiene il gestore eventi.

In un impeto di lieve fastidio, ho appena aggiunto il gestore eventi alla proprietà Get che accede all'oggetto. Viene chiamato ora, il che è fantastico, tranne per il fatto che viene chiamato come 5 volte, quindi penso che il gestore continui ad essere aggiunto ogni volta che si accede all'oggetto.

È abbastanza sicuro da ignorare, ma preferirei renderlo molto più pulito controllando se il gestore è già stato aggiunto, quindi lo faccio solo una volta.

È possibile?

EDIT: Non ho necessariamente il pieno controllo di quali gestori di eventi vengono aggiunti, quindi il solo controllo di null non è abbastanza buono.

Al di fuori della classe che definisce, come menziona @Telos, puoi usare EventHandler solo sul lato sinistro di a +=o a -=. Pertanto, se si ha la possibilità di modificare la classe di definizione, è possibile fornire un metodo per eseguire il controllo controllando se il gestore eventi è null- in tal caso, non è stato aggiunto alcun gestore eventi. In caso contrario, forse e puoi scorrere i valori in Delegate.GetInvocationList . Se uno è uguale al delegato che desideri aggiungere come gestore eventi, sai che è lì.

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

E questo potrebbe essere facilmente modificato per diventare "aggiungi il gestore se non è lì". Se non hai accesso alle viscere della classe che espone l'evento, potrebbe essere necessario esplorare -=e +=, come suggerito da @Lou Franco.

Tuttavia, potresti essere meglio riesaminare il modo in cui stai commissionando e smantellando questi oggetti, per vedere se non riesci a trovare un modo per tracciare queste informazioni tu stesso.

Recentemente sono arrivato a una situazione simile in cui dovevo registrare un gestore per un evento solo una volta. Ho scoperto che puoi prima annullare la registrazione in modo sicuro e quindi registrarti di nuovo, anche se il gestore non è registrato affatto:

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

Notare che ogni volta che si registra il gestore, si assicurerà che il gestore sia registrato una sola volta. Mi sembra una buona pratica :)

Se questo è l'unico gestore, puoi verificare se l'evento è nullo, in caso contrario il gestore è stato aggiunto.

Penso che puoi tranquillamente chiamare - = sull'evento con il tuo gestore anche se non viene aggiunto (in caso contrario, potresti prenderlo) - per assicurarti che non sia presente prima di aggiungere.

Questo esempio mostra come utilizzare il metodo GetInvocationList () per recuperare i delegati a tutti i gestori che sono stati aggiunti. Se stai cercando di vedere se è stato aggiunto un gestore (funzione) specifico, puoi usare l'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

È possibile esaminare varie proprietà della proprietà Method del delegato per verificare se è stata aggiunta una funzione specifica.

Se stai cercando di vedere se ce n'è solo uno attaccato, puoi semplicemente provare a null.

Se capisco correttamente il tuo problema potresti avere problemi più grandi. Hai detto che altri oggetti possono iscriversi a questi eventi. Quando l'oggetto viene serializzato e deserializzato, gli altri oggetti (quelli di cui non si ha il controllo) perderanno i gestori di eventi.

Se non ti preoccupi, mantenere un riferimento al gestore dell'evento dovrebbe essere abbastanza buono. Se sei preoccupato per gli effetti collaterali di altri oggetti che perdono i gestori di eventi, allora potresti voler ripensare la tua strategia di memorizzazione nella cache.

sono d'accordo con la risposta di alf, ma poche modifiche ad esso sono, da usare,

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

L'unico modo che ha funzionato per me è creare una variabile booleana che ho impostato su true quando aggiungo l'evento. Quindi chiedo: se la variabile è falsa, aggiungo l'evento.

bool alreadyAdded = false;

Questa variabile può essere globale.

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

EventHandler.GetInvocationList().Length > 0