Отписаться анонимный метод в C #

Можно ли отписаться анонимным методом от события?

Если я подпишусь на такое событие:

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

MyEvent += MyMethod;

Я могу отменить подписку, как это:

MyEvent -= MyMethod;

Но если я подпишусь, используя анонимный метод:

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

Можно ли отписаться от этого анонимного метода? Если да, то как?

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

MyEvent += myDelegate;


// .... later

MyEvent -= myDelegate;

Просто держите ссылку на делегата.

Одним из методов является объявление переменной для хранения анонимного метода, который затем будет доступен внутри самого анонимного метода. Это сработало для меня, потому что желаемое поведение было отписаться после обработки события.

Пример:

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

Исходя из памяти, спецификация явно не гарантирует поведения в любом случае, когда речь идет об эквивалентности делегатов, созданных анонимными методами.

Если вам нужно отменить подписку, вы должны либо использовать «обычный» метод, либо оставить делегат где-то еще, чтобы вы могли отписаться точно таким же делегатом, который вы использовали для подписки.

В 3.0 можно сократить до:

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

Поскольку C # 7.0 локальных функций функции была отпущена, подход предложил на J с становится очень аккуратным.

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

Так что, честно говоря, у вас нет анонимной функции в качестве переменной здесь. Но я полагаю, что мотивация использовать его в вашем случае может быть применена к локальным функциям.

Вместо того, чтобы хранить ссылку на любой делегат, вы можете использовать свой класс, чтобы вернуть список вызовов события вызывающей стороне. По сути, вы можете написать что-то вроде этого (при условии, что MyEvent объявлен внутри MyClass):

public class MyClass 
{
  public event EventHandler MyEvent;

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

Таким образом, вы можете получить доступ ко всему списку вызовов извне MyClass и отписаться от любого обработчика, который вы хотите. Например:

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

Я написал полный пост об этой технике здесь .

Вид отстойного подхода:

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

  ...

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

1. Переопределить событие добавить / удалить методы.
2. Держите список этих обработчиков событий.
3. При необходимости очистите их все и добавьте остальные.

Это может не сработать или быть наиболее эффективным методом, но должно выполнить работу.

Если вы хотите иметь возможность контролировать отписку, вам нужно идти по маршруту, указанному в принятом ответе. Однако, если вы просто заинтересованы в очистке ссылок, когда ваш подписывающийся класс выходит из области видимости, то есть другое (немного запутанное) решение, которое включает использование слабых ссылок. Я только что опубликовал вопрос и ответ по этой теме.

Одно простое решение:

просто передайте переменную EventHandle в качестве параметра для себя. Событие, если у вас есть случай, когда вы не можете получить доступ к первоначально созданной переменной из-за многопоточности, вы можете использовать это:

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

если вы хотите обратиться к какому-либо объекту с этим делегатом, возможно, вы можете использовать Delegate.CreateDelegate (Type, Object target, MethodInfo methodInfo) .net считают, что делегат равен по target и methodInfo

Если лучший способ - сохранить ссылку на подписанный eventHandler, это можно сделать с помощью словаря.

В этом примере я должен использовать анонимный метод, чтобы включить параметр mergeColumn для набора DataGridViews.

Использование метода MergeColumn с параметром enable, для которого установлено значение true, включает событие, а использование с параметром false отключает его.

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