Prendi la seguente classe C #:

c1 {
 event EventHandler someEvent;
}

Se ci sono un sacco di abbonamenti a c1's someEventevento e voglio eliminarli tutti, qual è il modo migliore per raggiungere questo obiettivo? Considera anche che gli abbonamenti a questo evento potrebbero essere / sono lambdas / delegati anonimi.

Attualmente la mia soluzione è aggiungere un ResetSubscriptions()metodo a c1quello impostato someEventsu null. Non so se questo abbia conseguenze invisibili.

Dall'interno della classe, puoi impostare la variabile (nascosta) su null. Un riferimento null è il modo canonico di rappresentare un elenco di invocazioni vuoto, in modo efficace.

Al di fuori della classe, non puoi farlo - gli eventi sostanzialmente espongono "iscriviti" e "annulla iscrizione" e il gioco è fatto.

Vale la pena essere consapevoli di cosa stanno realmente facendo eventi simili a un campo: stanno creando una variabile e un evento allo stesso tempo. All'interno della classe, si finisce per fare riferimento alla variabile. Dall'esterno, fai riferimento all'evento.

Vedi il mio articolo su eventi e delegati per ulteriori informazioni.

Aggiungi un metodo a c1 che imposterà 'someEvent' su null.

public class c1
{
    event EventHandler someEvent;
    public ResetSubscriptions() => someEvent = null;    
}

class c1
{
    event EventHandler someEvent;
    ResetSubscriptions() => someEvent = delegate { };
}

È meglio utilizzare delegate { }che nullper evitare l'eccezione riferimento null.

L'impostazione dell'evento su null all'interno della classe funziona. Quando si elimina una classe, è sempre necessario impostare l'evento su null, il GC ha problemi con gli eventi e potrebbe non ripulire la classe eliminata se presenta eventi sospesi.

La migliore pratica per cancellare tutti gli abbonati è di impostare someEvent su null aggiungendo un altro metodo pubblico se si desidera esporre questa funzionalità all'esterno. Ciò non ha conseguenze invisibili. Il presupposto è ricordare di dichiarare SomeEvent con la parola chiave "evento".

Si prega di consultare il libro - C # 4.0 in breve, pagina 125.

Qualcuno qui ha proposto di utilizzare il Delegate.RemoveAllmetodo. Se lo usi, il codice di esempio potrebbe seguire il modulo seguente. Ma è davvero stupido. Perché non solo SomeEvent=nullall'interno della ClearSubscribers()funzione?

public void ClearSubscribers ()
{
   SomeEvent = (EventHandler) Delegate.RemoveAll(SomeEvent, SomeEvent);
   // Then you will find SomeEvent is set to null.
}

È possibile ottenere ciò utilizzando i metodi Delegate.Remove o Delegate.RemoveAll.

Commento concettuale esteso noioso.

Preferisco usare la parola "gestore eventi" anziché "evento" o "delegato". E ha usato la parola "evento" per altre cose. In alcuni linguaggi di programmazione (VB.NET, Object Pascal, Objective-C), "evento" viene chiamato "messaggio" o "segnale" e ha persino una parola chiave "messaggio" e una sintassi specifica dello zucchero.

const
  WM_Paint = 998;  // <-- "question" can be done by several talkers
  WM_Clear = 546;

type
  MyWindowClass = class(Window)
    procedure NotEventHandlerMethod_1;
    procedure NotEventHandlerMethod_17;

    procedure DoPaintEventHandler; message WM_Paint; // <-- "answer" by this listener
    procedure DoClearEventHandler; message WM_Clear;
  end;

E, per rispondere a quel "messaggio", un "gestore di eventi" risponde, che sia un singolo delegato o più delegati.

Riepilogo: "Evento" è la "domanda", "i gestori di eventi" sono le risposte.

Questa è la mia soluzione:

public class Foo : IDisposable
{
    private event EventHandler _statusChanged;
    public event EventHandler StatusChanged
    {
        add
        {
            _statusChanged += value;
        }
        remove
        {
            _statusChanged -= value;
        }
    }

    public void Dispose()
    {
        _statusChanged = null;
    }
}

È necessario chiamare Dispose()o utilizzare il using(new Foo()){/*...*/}modello per annullare l'iscrizione a tutti i membri dell'elenco di invocazione.

Rimuovi tutti gli eventi, supponi che l'evento sia di tipo "Azione":

Delegate[] dary = TermCheckScore.GetInvocationList();

if ( dary != null )
{
    foreach ( Delegate del in dary )
    {
        TermCheckScore -= ( Action ) del;
    }
}

Invece di aggiungere e rimuovere callback manualmente e avere un gruppo di tipi di delegati dichiarati ovunque:

// The hard way
public delegate void ObjectCallback(ObjectType broadcaster);

public class Object
{
    public event ObjectCallback m_ObjectCallback;
    
    void SetupListener()
    {
        ObjectCallback callback = null;
        callback = (ObjectType broadcaster) =>
        {
            // one time logic here
            broadcaster.m_ObjectCallback -= callback;
        };
        m_ObjectCallback += callback;

    }
    
    void BroadcastEvent()
    {
        m_ObjectCallback?.Invoke(this);
    }
}

Puoi provare questo approccio generico:

public class Object
{
    public Broadcast<Object> m_EventToBroadcast = new Broadcast<Object>();

    void SetupListener()
    {
        m_EventToBroadcast.SubscribeOnce((ObjectType broadcaster) => {
            // one time logic here
        });
    }

    ~Object()
    {
        m_EventToBroadcast.Dispose();
        m_EventToBroadcast = null;
    }

    void BroadcastEvent()
    {
        m_EventToBroadcast.Broadcast(this);
    }
}


public delegate void ObjectDelegate<T>(T broadcaster);
public class Broadcast<T> : IDisposable
{
    private event ObjectDelegate<T> m_Event;
    private List<ObjectDelegate<T>> m_SingleSubscribers = new List<ObjectDelegate<T>>();

    ~Broadcast()
    {
        Dispose();
    }

    public void Dispose()
    {
        Clear();
        System.GC.SuppressFinalize(this);
    }

    public void Clear()
    {
        m_SingleSubscribers.Clear();
        m_Event = delegate { };
    }

    // add a one shot to this delegate that is removed after first broadcast
    public void SubscribeOnce(ObjectDelegate<T> del)
    {
        m_Event += del;
        m_SingleSubscribers.Add(del);
    }

    // add a recurring delegate that gets called each time
    public void Subscribe(ObjectDelegate<T> del)
    {
        m_Event += del;
    }

    public void Unsubscribe(ObjectDelegate<T> del)
    {
        m_Event -= del;
    }

    public void Broadcast(T broadcaster)
    {
        m_Event?.Invoke(broadcaster);
        for (int i = 0; i < m_SingleSubscribers.Count; ++i)
        {
            Unsubscribe(m_SingleSubscribers[i]);
        }
        m_SingleSubscribers.Clear();
    }
}