一个简单的解决办法:

只需将eventandle变量作为参数传递给自身。 事件，如果你的情况下，你不能访问原始创建的变量，因为多线程，你可以使用这个:

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

有一种方法可以通过自己实现闭包而不是lambda表达式来解决这个问题。

假设将用作捕获变量的类如下所示。

public class A
{
    public void DoSomething()
    {
        ...
    }
}

public class B
{
    public void DoSomething()
    {
        ...
    }
}

public class C
{
    public void DoSomething()
    {
        ...
    }
}

这些类将被用作捕获变量，因此我们对它们进行实例化。

A a = new A();
B b = new B();
C c = new C();

实现闭包类，如下所示。

private class EventHandlerClosure
{
    public A a;
    public B b;
    public C c;

    public event EventHandler Finished;

    public void MyMethod(object, MyEventArgs args)
    {
        a.DoSomething();
        b.DoSomething();
        c.DoSomething();
        Console.WriteLine("I did it!");

        Finished?.Invoke(this, EventArgs.Empty);
    }
}

实例化闭包类，创建一个处理程序，然后订阅事件并订阅从闭包类的Finished事件中取消订阅的lambda表达式。

var closure = new EventHandlerClosure
{
    a = a,
    b = b,
    c = c
};
var handler = new MyEventHandler(closure.MyMethod);
MyEvent += handler;
closure.Finished += (s, e)
{
    MyEvent -= handler;
}

如果最好的方法是在订阅的eventHandler上保持引用，则可以使用Dictionary来实现。

在本例中，我必须使用匿名方法为一组DataGridViews包含mergeColumn参数。

使用启用参数设置为true的MergeColumn方法启用事件，而使用设置为false的MergeColumn方法禁用事件。

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

一种技术是声明一个变量来保存匿名方法，该变量将在匿名方法本身内部可用。这对我来说很有效，因为我想要的行为是在事件处理后取消订阅。

例子:

MyEventHandler foo = null;
foo = delegate(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();

关于这个技巧，我已经写了一篇完整的文章。

一个简单的解决办法:

只需将eventandle变量作为参数传递给自身。 事件，如果你的情况下，你不能访问原始创建的变量，因为多线程，你可以使用这个:

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