Unsubscribe método anónimo en C#

Una técnica es declarar una variable para mantener el método anónimo que entonces estaría disponible dentro del propio método anónimo. Esto funcionó para mí porque el comportamiento deseado era cancelar la suscripción después de que se manejara el evento.

Ejemplo:

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

Desde la memoria, la especificación explícitamente no garantiza el comportamiento de ninguna manera cuando se trata de la equivalencia de delegados creados con métodos anónimos.

Si necesita darse de baja, debe usar un método "normal" o conservar el delegado en otro lugar para que pueda darse de baja exactamente con el mismo delegado que utilizó para suscribirse.

En 3.0 se puede acortar a:

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

En lugar de mantener una referencia a cualquier delegado, puede instrumentar su clase para devolver la lista de invocación del evento al llamante. Básicamente puedes escribir algo como esto (asumiendo que MyEvent es declarado dentro de MyClass):

public class MyClass 
{
  public event EventHandler MyEvent;

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

Para que pueda acceder a toda la lista de invocaciones desde fuera de MyClass y cancelar la suscripción a cualquier controlador que desee. Por ejemplo:

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

He escrito un post completo sobre esta técnica aquí.

Tipo de enfoque cojo:

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

  ...

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

1. Invalida los métodos de evento add/remove.
2. Mantenga una lista de esos controladores de eventos.
3. Cuando sea necesario, límpielos todos y vuelva a agregar los demás.

Esto puede no funcionar o ser el método más eficiente, pero debe hacer el trabajo.

Desde que C# 7.0 funciones locales se ha liberado la característica, el enfoque sugerido por jc se vuelve realmente limpio.

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

Así que, honestamente, no tienes una función anónima como variable aquí. Pero supongo que la motivación para usarlo en su caso se puede aplicar a las funciones locales.

Si desea poder controlar la cancelación de suscripción, debe seguir la ruta indicada en su respuesta aceptada. Sin embargo, si solo le preocupa aclarar las referencias cuando su clase de suscripción se sale de su alcance, entonces hay otra solución (ligeramente complicada) que implica usar referencias débiles. Acabo de publicar una pregunta y respuesta sobre este tema.

Una solución simple:

Simplemente pase la variable eventhandle como parámetro a sí misma. Evento si tiene el caso de que no puede acceder a la variable creada original debido a multihilo, puede usar esto:

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

Si desea referirse a algún objeto con este delegado, puede ser que pueda usar Delegado.CreateDelegate (Type, Object target, MethodInfo MethodInfo) . net considera que el delegado es igual por target y MethodInfo

Si la mejor manera es mantener una referencia en el EventHandler suscrito, esto se puede lograr usando un diccionario.

En este ejemplo, tengo que usar un método anónimo para incluir el parámetro mergeColumn para un conjunto de DataGridViews.

Usar el método MergeColumn con el parámetro enable establecido en true habilita el evento mientras que usarlo con false lo deshabilita.

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