Annulla l'iscrizione al metodo anonimo in C #

È possibile annullare l'iscrizione di un metodo anonimo a un evento?

Se mi iscrivo a un evento come questo:

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

MyEvent += MyMethod;

Posso annullare l'iscrizione in questo modo:

MyEvent -= MyMethod;

Ma se mi iscrivo usando un metodo anonimo:

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

è possibile annullare l'iscrizione a questo metodo anonimo? Se é cosi, come?

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

MyEvent += myDelegate;


// .... later

MyEvent -= myDelegate;

Basta tenere un riferimento al delegato in giro.

Una tecnica consiste nel dichiarare una variabile per contenere il metodo anonimo che sarebbe quindi disponibile all'interno del metodo anonimo stesso. Questo ha funzionato per me perché il comportamento desiderato era l'annullamento dell'iscrizione dopo la gestione dell'evento.

Esempio:

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

Dalla memoria, la specifica non garantisce esplicitamente il comportamento in entrambi i casi quando si tratta di equivalenza di delegati creati con metodi anonimi.

Se è necessario annullare l'iscrizione, è necessario utilizzare un metodo "normale" o conservare il delegato altrove in modo da poter annullare l'iscrizione esattamente con lo stesso delegato utilizzato per l'abbonamento.

In 3.0 può essere abbreviato in:

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

Poiché la funzione delle funzioni locali di C # 7.0 è stata rilasciata, l'approccio suggerito da J c diventa davvero pulito.

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

Quindi, onestamente, non hai una funzione anonima come variabile qui. Ma suppongo che la motivazione per usarlo nel tuo caso possa essere applicata alle funzioni locali.

Invece di mantenere un riferimento a qualsiasi delegato, puoi strumentare la tua classe per restituire al chiamante l'elenco di invocazione dell'evento. Fondamentalmente puoi scrivere qualcosa del genere (supponendo che MyEvent sia dichiarato all'interno di MyClass):

public class MyClass 
{
  public event EventHandler MyEvent;

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

Quindi puoi accedere all'intero elenco di invocazioni dall'esterno di MyClass e annullare l'iscrizione a qualsiasi gestore che desideri. Per esempio:

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

Ho scritto un post completo su questa tecnica qui .

Approccio tipo di zoppo:

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

  ...

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

1. Sostituisci i metodi di aggiunta / rimozione dell'evento.
2. Tenere un elenco di quei gestori di eventi.
3. Se necessario, cancellali tutti e aggiungi nuovamente gli altri.

Questo potrebbe non funzionare o essere il metodo più efficiente, ma dovrebbe portare a termine il lavoro.

Se vuoi essere in grado di controllare l'annullamento dell'iscrizione, devi seguire il percorso indicato nella risposta accettata. Tuttavia, se sei solo preoccupato di chiarire i riferimenti quando la tua classe di abbonamento esce dal campo di applicazione, esiste un'altra soluzione (leggermente contorta) che prevede l'utilizzo di riferimenti deboli. Ho appena pubblicato una domanda e una risposta su questo argomento.

Una soluzione semplice:

passa la variabile eventhandle come parametro a se stessa. Evento se si ha il caso in cui non è possibile accedere alla variabile creata originale a causa del multithreading, è possibile utilizzare questo:

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

se si desidera fare riferimento a un oggetto con questo delegato, è possibile utilizzare Delegate.CreateDelegate (Type, Object target, MethodInfo methodInfo) .net considerare il delegato uguale a target e methodInfo

Se il modo migliore è mantenere un riferimento sull'eventoHandler sottoscritto, questo può essere ottenuto usando un Dizionario.

In questo esempio, devo usare un metodo anonimo per includere il parametro mergeColumn per un set di DataGridViews.

L'uso del metodo MergeColumn con il parametro enable impostato su true abilita l'evento mentre lo utilizza con false lo disabilita.

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