Prenez la classe C # suivante:

c1 {
 event EventHandler someEvent;
}

S'il y a beaucoup d'abonnements à c1l' someEventévénement de s et que je souhaite tous les effacer, quelle est la meilleure façon d'y parvenir? Considérez également que les abonnements à cet événement peuvent être / sont des lambdas / des délégués anonymes.

Actuellement, ma solution consiste à ajouter une ResetSubscriptions()méthode à c1celle définie someEventsur null. Je ne sais pas si cela a des conséquences invisibles.

À partir de la classe, vous pouvez définir la variable (masquée) sur null. Une référence nulle est la manière canonique de représenter efficacement une liste d'appels vide.

De l'extérieur de la classe, vous ne pouvez pas faire cela - les événements exposent essentiellement "s'abonner" et "se désabonner" et c'est tout.

Il vaut la peine d'être conscient de ce que font réellement les événements de type champ - ils créent une variable et un événement en même temps. Au sein de la classe, vous finissez par référencer la variable. De l'extérieur, vous faites référence à l'événement.

Voir mon article sur les événements et les délégués pour plus d'informations.

Ajoutez une méthode à c1 qui définira 'someEvent' sur null.

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

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

Il vaut mieux utiliser delegate { }que nulld'éviter l'exception de référence nulle.

Définir l'événement sur null dans la classe fonctionne. Lorsque vous supprimez une classe, vous devez toujours définir l'événement sur null, le GC a des problèmes avec les événements et peut ne pas nettoyer la classe supprimée si elle a des événements en suspens.

La meilleure pratique pour effacer tous les abonnés consiste à définir someEvent sur null en ajoutant une autre méthode publique si vous souhaitez exposer cette fonctionnalité à l'extérieur. Cela n'a pas de conséquences invisibles. La condition préalable est de ne pas oublier de déclarer SomeEvent avec le mot-clé 'event'.

Veuillez consulter le livre - C # 4.0 en bref, page 125.

Quelqu'un ici a proposé d'utiliser la Delegate.RemoveAllméthode. Si vous l'utilisez, l'exemple de code peut suivre le formulaire ci-dessous. Mais c'est vraiment stupide. Pourquoi pas juste SomeEvent=nullà l'intérieur de la ClearSubscribers()fonction?

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

Vous pouvez y parvenir en utilisant les méthodes Delegate.Remove ou Delegate.RemoveAll.

Commentaire ennuyeux prolongé conceptuel.

J'utilise plutôt le mot "gestionnaire d'événements" au lieu de "événement" ou "délégué". Et utilisé le mot «événement» pour d'autres choses. Dans certains langages de programmation (VB.NET, Object Pascal, Objective-C), "event" est appelé "message" ou "signal", et a même un mot-clé "message" et une syntaxe de sucre spécifique.

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;

Et, pour répondre à ce "message", un "gestionnaire d'événements" répond, qu'il s'agisse d'un seul délégué ou de plusieurs délégués.

Résumé: "Event" est la "question", "event handler (s)" are the answer (s).

Voici ma solution:

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

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

Vous devez appeler Dispose()ou utiliser un using(new Foo()){/*...*/}modèle pour désinscrire tous les membres de la liste d'appel.

Supprimez tous les événements, supposons que l'événement est de type "Action":

Delegate[] dary = TermCheckScore.GetInvocationList();

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

Au lieu d'ajouter et de supprimer des rappels manuellement et d'avoir un tas de types de délégués déclarés partout:

// 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);
    }
}

Vous pouvez essayer cette approche générique:

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();
    }
}