C# patrón para evitar un controlador de eventos enganchó dos veces

Question

Duplicado de: How to ensure an event is only subscribed to once y Has an event handler already been added?

tengo un producto único que proporciona algún servicio y mis clases enganchan en algunos eventos en él, a veces una clase es conectar dos veces para el evento y luego se llama dos veces. Estoy buscando una forma clásica de evitar que esto suceda. de alguna manera tengo que verificar si ya me he conectado a este evento ...

Answer 1

Implemente explícitamente el evento y compruebe la lista de invocación. También tendrá que comprobar para nulo:

using System.Linq; // Required for the .Contains call below: 

... 

private EventHandler foo; 
public event EventHandler Foo 
{ 
    add 
    { 
     if (foo == null || !foo.GetInvocationList().Contains(value)) 
     { 
      foo += value; 
     } 
    } 
    remove 
    { 
     foo -= value; 
    } 
} 

Usando el código anterior, si una persona que llama se suscribe al evento varias veces, simplemente se ignora.

Answer 2

Debe implementar agregar y quitar accesos en el evento, y luego verificar la lista de objetivos del delegado, o almacenar los objetivos en un lista.

En el método add, puede usar el método Delegate.GetInvocationList para obtener una lista de los objetivos que ya se han agregado al delegado.

Dado que los delegados se definen para comparar iguales si están vinculados al mismo método en el mismo objeto de destino, probablemente podría ejecutar esa lista y comparar, y si no encuentra ninguno que compare igual, agregue el nuevo .

Aquí es código de ejemplo, los datos como aplicación de consola:

using System; 
using System.Linq; 

namespace DemoApp 
{ 
    public class TestClass 
    { 
     private EventHandler _Test; 

     public event EventHandler Test 
     { 
      add 
      { 
       if (_Test == null || !_Test.GetInvocationList().Contains(value)) 
        _Test += value; 
      } 

      remove 
      { 
       _Test -= value; 
      } 
     } 

     public void OnTest() 
     { 
      if (_Test != null) 
       _Test(this, EventArgs.Empty); 
     } 
    } 

    class Program 
    { 
     static void Main() 
     { 
      TestClass tc = new TestClass(); 
      tc.Test += tc_Test; 
      tc.Test += tc_Test; 
      tc.OnTest(); 
      Console.In.ReadLine(); 
     } 

     static void tc_Test(object sender, EventArgs e) 
     { 
      Console.Out.WriteLine("tc_Test called"); 
     } 
    } 
} 

Salida:

tc_Test called 

(es decir, sólo una vez).

Answer 3

tienen comprobar su objeto único es la lista de los que se notifica y solo llama una vez si está duplicado. Alternativamente, si es posible, rechace la solicitud de archivo adjunto.

Answer 4

Tal vez mi respuesta a un puesto similar ayudará a:

Differentiating between events raised by user interaction and my own code

Answer 5

Usted realmente debe manejar esto a nivel fregadero y no al nivel de la fuente. Es decir, no prescriba la lógica del controlador de eventos en el origen del evento; déjelo en manos de los manejadores (los sumideros).

Como desarrollador de un servicio, ¿quién dice que los sumideros solo pueden registrarse una vez? ¿Qué pasa si quieren registrarse dos veces por alguna razón? Y si está tratando de corregir errores en los sumideros modificando la fuente, de nuevo es una buena razón para corregir estos problemas en el nivel de sumidero.

Estoy seguro de que tiene sus razones; una fuente de eventos para los cuales los sumideros duplicados son ilegales no es insondable. Pero tal vez deberías considerar una arquitectura alternativa que deje intacta la semántica de un evento.

Answer 6

¿Qué tal sólo la eliminación de caso primero con -=, si no se encuentra una excepción no se lanza

/// -= Removes the event if it has been already added, this prevents multiple firing of the event 
((System.Windows.Forms.WebBrowser)sender).Document.Click -= new System.Windows.Forms.HtmlElementEventHandler(testii); 
((System.Windows.Forms.WebBrowser)sender).Document.Click += new System.Windows.Forms.HtmlElementEventHandler(testii); 

Answer 7

de Reactive Extensions (Rx) framework Microsoft también se puede utilizar para hacer "subscribe una sola vez".

Dado un evento de ratón foo.Clicked, aquí es cómo suscribirse y recibir una única invocación:

Observable.FromEvent<MouseEventArgs>(foo, "Clicked") 
    .Take(1) 
    .Subscribe(MyHandler); 

... 

private void MyHandler(IEvent<MouseEventArgs> eventInfo) 
{ 
    // This will be called just once! 
    var sender = eventInfo.Sender; 
    var args = eventInfo.EventArgs; 
} 

Además de proporcionar "subscribe vez" funcionalidad, el enfoque RX ofrece la capacidad de componer juntos eventos o filtrar eventos. Es bastante ingenioso

Answer 8

En silverlight debe decir e.Handled = true; en el código del evento.

void image_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) 
{ 
    e.Handled = true; //this fixes the double event fire problem. 
    string name = (e.OriginalSource as Image).Tag.ToString(); 
    DoSomething(name); 
} 

Por favor, activa conmigo si esto ayuda.

Answer 9

Crea una acción en lugar de un evento. Su clase puede verse como:

public class MyClass 
{ 
       // sender arguments  <-----  Use this action instead of an event 
    public Action<object, EventArgs> OnSomeEventOccured; 

    public void SomeMethod() 
    { 
      if(OnSomeEventOccured!=null) 
       OnSomeEventOccured(this, null); 
    } 

} 

Answer 10

He probado cada solución y la mejor (teniendo en cuenta el rendimiento) es:

private EventHandler _foo; 
public event EventHandler Foo { 

    add { 
     _foo -= value; 
     _foo += value; 
    } 
    remove { 
     _foo -= value; 
    } 
} 

Sin LINQ utilizando necesaria. No es necesario comprobar el nulo antes de cancelar una suscripción (ver MS EventHandler para más detalles). No hay necesidad de recordar hacer la cancelación en todas partes.