Dar de baja el método anónimo en C #

¿Es posible cancelar la suscripción a un método anónimo de un evento?

Si me suscribo a un evento como este:

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

MyEvent += MyMethod;

Puedo cancelar la suscripción de esta manera:

MyEvent -= MyMethod;

Pero si me suscribo usando un método anónimo:

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

¿Es posible darse de baja de este método anónimo? ¿Si es así, cómo?

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

MyEvent += myDelegate;


// .... later

MyEvent -= myDelegate;

Solo mantenga una referencia al delegado.

Una técnica es declarar una variable para contener el método anónimo que luego estaría disponible dentro del propio método anónimo. Esto funcionó para mí porque el comportamiento deseado era darse de baja después de que se manejó el evento.

Ejemplo:

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

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

Si necesita darse de baja, debe usar un método "normal" o retener al delegado en otro lugar para que pueda darse de baja con exactamente el mismo delegado que solía suscribirse.

En 3.0 se puede acortar a:

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

Desde que se lanzó la función de funciones locales C # 7.0 , el enfoque sugerido por J c se vuelve realmente claro.

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

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

En lugar de mantener una referencia a cualquier delegado, puede instrumentar su clase para devolver la lista de invocación del evento a la persona que llama. Básicamente, puede escribir algo como esto (suponiendo que MyEvent se declare dentro de MyClass):

public class MyClass 
{
  public event EventHandler MyEvent;

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

Por lo tanto, puede acceder a toda la lista de invocación desde fuera de MyClass y cancelar la suscripción de cualquier controlador que desee. Por ejemplo:

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

He escrito una publicación completa sobre esta técnica aquí .

Enfoque poco convincente:

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

  ...

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

1. Anular los métodos de agregar / eliminar eventos.
2. Mantenga una lista de esos controladores de eventos.
3. Cuando sea necesario, elimínelos 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.

Si desea controlar la cancelación de la suscripción, debe seguir la ruta indicada en su respuesta aceptada. Sin embargo, si solo le preocupa limpiar las referencias cuando su clase de suscripción queda fuera de alcance, entonces hay otra solución (ligeramente complicada) que implica el uso de 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 subprocesos múltiples, 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 usar Delegate.CreateDelegate (Type, Object target, MethodInfo methodInfo) .net considere que el delegado es igual por target y methodInfo

Si la mejor manera es mantener una referencia en 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.

El uso del método MergeColumn con el parámetro enable establecido en true habilita el evento mientras que el uso 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);
        }
    }
}