Deaktivieren Sie die anonyme Methode in C #

Ist es möglich, eine anonyme Methode von einem Ereignis abzumelden?

Wenn ich eine Veranstaltung wie diese abonniere:

void MyMethod()
{
    Console.WriteLine("I did it!");
}

MyEvent += MyMethod;

Ich kann mich wie folgt abmelden:

MyEvent -= MyMethod;

Aber wenn ich mich mit einer anonymen Methode anmelde:

MyEvent += delegate(){Console.WriteLine("I did it!");};

Ist es möglich, diese anonyme Methode abzubestellen? Wenn das so ist, wie?

Action myDelegate = delegate(){Console.WriteLine("I did it!");};

MyEvent += myDelegate;


// .... later

MyEvent -= myDelegate;

Behalten Sie einfach einen Verweis auf den Delegierten in der Nähe.

Eine Technik besteht darin, eine Variable zu deklarieren, die die anonyme Methode enthält, die dann in der anonymen Methode selbst verfügbar wäre. Dies funktionierte für mich, da das gewünschte Verhalten darin bestand, sich abzumelden, nachdem das Ereignis behandelt wurde.

Beispiel:

MyEventHandler foo = null;
foo = delegate(object s, MyEventArgs ev)
    {
        Console.WriteLine("I did it!");
        MyEvent -= foo;
    };
MyEvent += foo;

Aus dem Speicher garantiert die Spezifikation das Verhalten in Bezug auf die Äquivalenz von Delegaten, die mit anonymen Methoden erstellt wurden, in keiner Weise.

Wenn Sie sich abmelden müssen, sollten Sie entweder eine "normale" Methode verwenden oder den Delegaten an einer anderen Stelle behalten, damit Sie sich mit genau demselben Delegaten abmelden können, den Sie zum Abonnieren verwendet haben.

In 3.0 kann verkürzt werden auf:

MyHandler myDelegate = ()=>Console.WriteLine("I did it!");
MyEvent += myDelegate;
...
MyEvent -= myDelegate;

Da die Funktion für lokale Funktionen von C # 7.0 veröffentlicht wurde, wird der von J c vorgeschlagene Ansatz wirklich ordentlich.

void foo(object s, MyEventArgs ev)
{
    Console.WriteLine("I did it!");
    MyEvent -= foo;
};
MyEvent += foo;

Ehrlich gesagt haben Sie hier keine anonyme Funktion als Variable. Aber ich nehme an, die Motivation, es in Ihrem Fall zu verwenden, kann auf lokale Funktionen angewendet werden.

Anstatt einen Verweis auf einen Delegierten zu behalten, können Sie Ihre Klasse instrumentieren, um die Aufrufliste des Ereignisses an den Anrufer zurückzugeben. Grundsätzlich können Sie so etwas schreiben (vorausgesetzt, MyEvent ist in MyClass deklariert):

public class MyClass 
{
  public event EventHandler MyEvent;

  public IEnumerable<EventHandler> GetMyEventHandlers()  
  {  
      return from d in MyEvent.GetInvocationList()  
             select (EventHandler)d;  
  }  
}

So können Sie von außerhalb von MyClass auf die gesamte Aufrufliste zugreifen und jeden gewünschten Handler abbestellen. Zum Beispiel:

myClass.MyEvent -= myClass.GetMyEventHandlers().Last();

Ich habe einen vollständigen Beitrag über dieses tecnique geschrieben hier .

Art von lahmem Ansatz:

public class SomeClass
{
  private readonly IList<Action> _eventList = new List<Action>();

  ...

  public event Action OnDoSomething
  {
    add {
      _eventList.Add(value);
    }
    remove {
      _eventList.Remove(value);
    }
  }
}

1. Überschreiben Sie die Methoden zum Hinzufügen / Entfernen von Ereignissen.
2. Führen Sie eine Liste dieser Ereignishandler.
3. Löschen Sie sie bei Bedarf alle und fügen Sie die anderen erneut hinzu.

Dies funktioniert möglicherweise nicht oder ist die effizienteste Methode, sollte aber die Arbeit erledigen.

Wenn Sie die Abmeldung kontrollieren möchten, müssen Sie den in Ihrer akzeptierten Antwort angegebenen Weg gehen. Wenn Sie jedoch nur Bedenken haben, Referenzen zu löschen, wenn Ihre abonnierende Klasse den Gültigkeitsbereich verlässt, gibt es eine andere (leicht verschlungene) Lösung, bei der schwache Referenzen verwendet werden. Ich habe gerade eine Frage und Antwort zu diesem Thema gepostet .

Eine einfache Lösung:

Übergeben Sie einfach die eventhandle-Variable als Parameter an sich selbst. Wenn Sie den Fall haben, dass Sie aufgrund von Multithreading nicht auf die ursprünglich erstellte Variable zugreifen können, können Sie Folgendes verwenden:

MyEventHandler foo = null;
foo = (s, ev, mehi) => MyMethod(s, ev, foo);
MyEvent += foo;

void MyMethod(object s, MyEventArgs ev, MyEventHandler myEventHandlerInstance)
{
    MyEvent -= myEventHandlerInstance;
    Console.WriteLine("I did it!");
}

Wenn Sie mit diesem Delegaten auf ein Objekt verweisen möchten, können Sie möglicherweise Delegate.CreateDelegate (Typ, Objektziel, MethodInfo methodInfo) .net verwenden

Wenn der beste Weg darin besteht, eine Referenz auf dem abonnierten eventHandler zu behalten, kann dies mithilfe eines Wörterbuchs erreicht werden.

In diesem Beispiel muss ich eine anonyme Methode verwenden, um den Parameter mergeColumn für eine Reihe von DataGridViews einzuschließen.

Die Verwendung der MergeColumn-Methode mit dem auf true gesetzten Parameter enable aktiviert das Ereignis, während die Verwendung mit false es deaktiviert.

static Dictionary<DataGridView, PaintEventHandler> subscriptions = new Dictionary<DataGridView, PaintEventHandler>();

public static void MergeColumns(this DataGridView dg, bool enable, params ColumnGroup[] mergedColumns) {

    if(enable) {
        subscriptions[dg] = (s, e) => Dg_Paint(s, e, mergedColumns);
        dg.Paint += subscriptions[dg];
    }
    else {
        if(subscriptions.ContainsKey(dg)) {
            dg.Paint -= subscriptions[dg];
            subscriptions.Remove(dg);
        }
    }
}