Weź następującą klasę C #:

c1 {
 event EventHandler someEvent;
}

Jeśli istnieje wiele prenumeraty c1„s someEventimprezy i chcę je wszystkie usunąć, co jest najlepszym sposobem osiągnięcia tego celu? Weź również pod uwagę, że subskrypcje tego zdarzenia mogą być / są lambdami / anonimowymi delegatami.

Obecnie moim rozwiązaniem jest dodanie ResetSubscriptions()metody do c1tych zestawów someEventna null. Nie wiem, czy ma to jakieś niewidoczne konsekwencje.

Z poziomu klasy możesz ustawić (ukrytą) zmienną na null. Odwołanie zerowe to kanoniczny sposób efektywnego reprezentowania pustej listy wywołań.

Poza zajęciami nie możesz tego zrobić - wydarzenia w zasadzie ujawniają „subskrybuj” i „anuluj subskrypcję” i to wszystko.

Warto być świadomym tego, co tak naprawdę robią wydarzenia polowe - tworzą zmienną i zdarzenie w tym samym czasie. W ramach klasy odwołujesz się do zmiennej. Z zewnątrz nawiązujesz do wydarzenia.

Zobacz mój artykuł na temat wydarzeń i delegatów, aby uzyskać więcej informacji.

Dodaj metodę do c1, która ustawi „someEvent” na null.

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

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

Lepiej jest używać delegate { }niż nullunikać zerowego wyjątku ref.

Ustawienie zdarzenia na null wewnątrz klasy działa. Po usunięciu klasy należy zawsze ustawić zdarzenie na null, GC ma problemy ze zdarzeniami i może nie wyczyścić usuniętej klasy, jeśli ma wiszące zdarzenia.

Najlepszą praktyką w celu wyczyszczenia wszystkich subskrybentów jest ustawienie someEvent na wartość null przez dodanie innej metody publicznej, jeśli chcesz udostępnić tę funkcję na zewnątrz. Nie ma to niewidocznych konsekwencji. Warunkiem wstępnym jest pamiętanie o zadeklarowaniu SomeEvent ze słowem kluczowym „event”.

Proszę zobaczyć książkę - C # 4.0 w pigułce, strona 125.

Ktoś tutaj zaproponował użycie Delegate.RemoveAllmetody. Jeśli go używasz, przykładowy kod może być zgodny z poniższym formularzem. Ale to jest naprawdę głupie. Dlaczego nie tylko SomeEvent=nullwewnątrz ClearSubscribers()funkcji?

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

Można to osiągnąć za pomocą metod Delegate.Remove lub Delegate.RemoveAll.

Koncepcyjny rozszerzony nudny komentarz.

Raczej używam słowa „obsługa zdarzeń” zamiast „zdarzenie” lub „delegat”. I użył słowa „wydarzenie” dla innych rzeczy. W niektórych językach programowania (VB.NET, Object Pascal, Objective-C) „zdarzenie” jest nazywane „komunikatem” lub „sygnałem”, a nawet ma słowo kluczowe „wiadomość” i określoną składnię cukru.

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;

Aby odpowiedzieć na ten „komunikat”, odpowiada „program obsługi zdarzeń”, niezależnie od tego, czy jest to pojedynczy delegat, czy wielu delegatów.

Podsumowanie: „zdarzenie” to „pytanie”, „obsługa zdarzeń” to odpowiedź (odpowiedzi).

To jest moje rozwiązanie:

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

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

Musisz zadzwonić Dispose()lub użyć using(new Foo()){/*...*/}wzorca, aby wypisać się ze wszystkich członków listy wywołań.

Usuń wszystkie zdarzenia, załóżmy, że zdarzenie jest typu „Działanie”:

Delegate[] dary = TermCheckScore.GetInvocationList();

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

Zamiast ręcznie dodawać i usuwać wywołania zwrotne i mieć wszędzie zadeklarowaną grupę typów delegatów:

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

Możesz wypróbować to ogólne podejście:

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