Rezygnacja z anonimowej metody w C#

Jedną z technik jest zadeklarowanie zmiennej przechowującej metodę anonimową, która byłaby dostępna wewnątrz samej metody anonimowej. Zadziałało to dla mnie, ponieważ pożądanym zachowaniem było wypisanie się po zakończeniu wydarzenia.

Przykład:

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

Z pamięci, Specyfikacja jawnie nie gwarantuje zachowania w żaden sposób, jeśli chodzi o równoważność delegatów utworzonych za pomocą metod anonimowych.

Jeśli chcesz zrezygnować z subskrypcji, powinieneś użyć "normalnej" metody lub zatrzymać delegata w innym miejscu, aby móc zrezygnować z subskrypcji z dokładnie tym samym delegatem, którego użyłeś do subskrypcji.

W 3.0 można skrócić do:

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

Zamiast odwoływać się do dowolnego delegata, możesz użyć swojej klasy, aby przekazać listę wywołania zdarzenia rozmówcy. Zasadniczo możesz napisać coś takiego (zakładając, że MyEvent jest zadeklarowany wewnątrz MyClass):

public class MyClass 
{
  public event EventHandler MyEvent;

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

Możesz więc uzyskać dostęp do całej listy wywołań spoza MyClass i zrezygnować z subskrypcji dowolnego programu obsługi. Na przykład:

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

Napisałem pełny post o tym tecnique tutaj .

Rodzaj lamerskiego podejścia:

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

  ...

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

1. nadpisuje metody dodawania/usuwania zdarzeń.
2. Zachowaj listę tych procedur obsługi zdarzeń.
3. w razie potrzeby wyczyść je wszystkie i ponownie dodaj pozostałe.

To może nie działać lub być najbardziej efektywną metodą, ale powinno wykonać zadanie.

Ponieważ C# 7.0 local functions feature została wydana, podejście zasugerowane przez J c staje się naprawdę schludne.

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

Więc, szczerze mówiąc, nie masz anonimowej funkcji jako zmiennej tutaj. Ale przypuszczam, że motywacja do korzystania z niego w Twoim przypadku może być zastosowana do lokalnych funkcji.

Jeśli chcesz mieć możliwość kontrolowania wypisania się, musisz przejść trasę wskazaną w zaakceptowanej odpowiedzi. Jeśli jednak po prostu martwisz się o wyczyszczenie referencji, gdy twoja klasa subskrybująca wychodzi poza zakres, istnieje inne (nieco zawiłe) rozwiązanie, które wymaga użycia słabych referencji. Właśnie zamieściłem pytanie i odpowiedź na ten temat.

Jedno proste rozwiązanie:

Wystarczy przekazać zmienną eventhandle jako parametr do siebie. Zdarzenie jeśli masz przypadek, że nie możesz uzyskać dostępu do oryginalnej utworzonej zmiennej z powodu wielowątkowości, możesz użyć tego:

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!");
}

Jeśli chcesz odnieść się do jakiegoś obiektu z tym delegatem, możesz użyć delegata.CreateDelegate (Type, Object target, MethodInfo methodInfo) . NET rozważ, że delegat jest równy przez target i methodInfo

Jeśli najlepszym sposobem jest zachowanie odniesienia na subskrybowanym eventhandlerze, można to osiągnąć za pomocą słownika.

W tym przykładzie muszę użyć anonimowej metody, aby dołączyć parametr Mergecolumn dla zestawu DataGridViews.

Użycie metody mergecolumn z parametrem enable ustawionym na true włącza zdarzenie, podczas gdy używanie go z false wyłącza.

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