que - programacion de eventos c#

Evite las suscripciones de eventos duplicados en C#

Question

¿Cómo sugeriría la mejor manera de evitar las suscripciones de eventos duplicados? Si esta línea de código se ejecuta en dos lugares, el evento se ejecutará dos veces. Estoy tratando de evitar que los eventos de terceros se suscriban dos veces.

theOBject.TheEvent += RunMyCode;

En mi configurador de delegados, puedo ejecutar este ...

theOBject.TheEvent -= RunMyCode;
theOBject.TheEvent += RunMyCode;

¿Pero es esa la mejor manera?

Answer 1

¿Su código es multihilo? El bloqueo de concurrencia solo es necesario cuando está en varios subprocesos. Si no es una sobrecarga.

Como tal, su enfoque de darse de baja y de suscribirse es correcto.

Gracias

Answer 2

Creo que, la forma más eficiente, es convertir su evento en una propiedad y agregarle bloqueos de concurrencia como en este Example :

private EventHandler _theEvent;
private object _eventLock = new object();
public event EventHandler TheEvent
{
    add
    {
        lock (_eventLock) 
        { 
            _theEvent -= value; 
            _theEvent += value; 
        }
    }
    remove
    {
        lock (_eventLock) 
        { 
           _theEvent -= value; 
        }
    }
}

Answer 3

He hecho esto antes ... asume que es aceptable que el último suscriptor sea el que recibe la llamada.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            MyObject my = new MyObject();
            my.Changed += new EventHandler(my_Changed);
            my.Changed += new EventHandler(my_Changed1);

            my.Update();
            Console.ReadLine();
        }

        static void my_Changed(object sender, EventArgs e)
        {
            Console.WriteLine("Hello");
        }
        static void my_Changed1(object sender, EventArgs e)
        {
            Console.WriteLine("Hello1");
        }
    }
    public class MyObject
    {
        public MyObject()
        {
        }
        private EventHandler ChangedEventHandler;
        public event EventHandler Changed
        {
            add
            {
                ChangedEventHandler = value;
            }
            remove
            {
                ChangedEventHandler -= value;
            }
        }
        public void Update()
        {
            OnChanged();
        }

        private void OnChanged()
        {
            if (ChangedEventHandler != null)
            {
                ChangedEventHandler(this, null);
            }
        }
    }
}

Answer 4

Si posee la fuente para la clase del objeto, entonces tiene acceso a la lista de invocación de TheEvent. Puede implementar su propio complemento de acceso para el evento y verificar antes de agregar.

Sin embargo, creo que su enfoque también está bien.

Answer 5

Yo uso su enfoque, excepto un detalle. Creo que los eventos se deben suscribir cuando crees una nueva instancia de suscriptor u Objeto, esto hace que el código sea más directo. Por lo tanto, todo lo que necesita es mirar cuidadosamente después de desechar los objetos correctos (desechar patten es una solución conveniente para esto).

Mencionó que usa un evento de terceros, eso significa que no puede proporcionar su propia realización para los métodos de agregar / eliminar, como se le ha recomendado. Pero en sus propias clases con sus propios eventos, debe definir su propia realización de los métodos de agregar / eliminar eventos para resolver su problema.