Anuluj subskrypcję metody anonimowej w języku C#

Question

Czy można wypisać anonimową metodę ze zdarzenia?

Gdybym zapisać się do takiego wydarzenia to:

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

MyEvent += MyMethod; 

mogę Zrezygnuj tak:

MyEvent -= MyMethod; 

Ale jeśli mogę zapisać za pomocą anonimowej metody:

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

Czy można zrezygnować z tej anonimowej metody? Jeśli tak to jak?

Answer 1

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

MyEvent += myDelegate; 


// .... later 

MyEvent -= myDelegate; 

Po prostu zachowaj odwołanie do delegata.

Answer 2

Specyfikacja z definicji 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, użyj metody "normalnej" lub zatrzymaj delegata gdzie indziej, aby móc zrezygnować z subskrypcji dokładnie tego samego uczestnika, którego użyto do zasubskrybowania.

Answer 3

Rodzaju lame 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. przesłonić zdarzenie dodać/usunąć metodami.
2. Zachowaj listę tych programów do obsługi zdarzeń.
3. W razie potrzeby wyczyść je wszystkie i dodaj ponownie pozostałe.

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

Answer 4

Jedną z technik jest zadeklarowanie zmiennej do przechowywania anonimowej metody, która byłaby wtedy dostępna w samej anonimowej metodzie. To działało dla mnie, ponieważ pożądane zachowanie polegało na rezygnacji z subskrypcji po rozpatrzeniu zdarzenia.

Przykład:

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

Answer 5

w 3,0 może być skrócony do:

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

Answer 6

Jeśli chcesz być w stanie kontrolować anulowanie subskrypcji to trzeba iść drogą wskazaną w akceptowanych odpowiedź. Jeśli jednak chodzi ci tylko o wyczyszczenie referencji, gdy twoja subskrybująca klasa wykracza poza zakres, istnieje inne (nieco zawiłe) rozwiązanie, które wymaga użycia słabych referencji. Właśnie opublikowałem question and answer na ten temat.

Answer 7

Zamiast zachowywać odwołanie do dowolnego delegata, możesz przyrządzić swoją klasę, aby przywrócić dzwoniącemu listę zdarzeń. W zasadzie można napisać coś takiego (zakładając, że MyEvent jest zadeklarowana wewnątrz MojaKlasa):

public class MyClass 
{ 
    public event EventHandler MyEvent; 

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

czemu można uzyskać dostęp do całej listy wywołania z zewnątrz MojaKlasa i wypisania żadnego obsługi chcesz.Na przykład:

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

Napisałem pełen post o tym tecnique here.

Answer 8

jeśli chcesz odnieść się do jakiegoś obiektu z tego delegata, może można użyć Delegate.CreateDelegate (rodzaj, cel Object, MethodInfo MethodInfo) .net rozważyć delegat równa się przez cel i MethodInfo

Answer 9

Jedno proste rozwiązanie :

wystarczy przekazać zmienną eventhandle jako parametr do samego siebie. Event jeśli masz sprawę, że nie można uzyskać dostęp do oryginalnej zmiennej utworzonej z powodu wielowątkowość, można użyć to:

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

Answer 10

Jeśli najlepszym sposobem jest, aby zachować odniesienie na subskrybowanych Podprogram ten można osiągnąć stosując słownik.

W tym przykładzie muszę użyć metody anonimowej do uwzględnienia parametru mergeColumn dla zestawu DataGridViews.

Użycie metody MergeColumn z ustawionym parametrem enable na wartość true powoduje, że zdarzenie podczas używania go z false powoduje jego dezaktywację.

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

Answer 11

Od C# 7.0 local functions funkcja została wydana, podejście suggested przez J c staje się naprawdę fajnie.

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

Szczerze mówiąc, nie ma tu anonimowej funkcji jako zmiennej. Ale przypuszczam, że motywacja do użycia go w twoim przypadku może być zastosowana do lokalnych funkcji.