[c#] ¿Cómo puedo borrar las suscripciones de eventos en C #?



Answers

Agregue un método a c1 que establecerá 'someEvent' a null ...

class c1
{
    event EventHandler someEvent;
    ResetSubscriptions() {someEvent = null;}
}
Question

Tome la siguiente clase de C #:

c1 {
 event EventHandler someEvent;
}

Si hay muchas suscripciones al evento someEvent c1 y quiero someEvent todas, ¿cuál es la mejor manera de lograrlo? También considere que las suscripciones a este evento podrían ser / son delegados lambdas / anónimos.

Actualmente mi solución es agregar un método ResetSubscriptions() a c1 que establece someEvent en nulo. No sé si esto tiene consecuencias no vistas.




Establecer el evento para anular dentro de la clase funciona. Cuando descarta una clase, siempre debe establecer el evento en nulo, el GC tiene problemas con los eventos y puede no limpiar la clase eliminada si tiene eventos colgantes.




La mejor práctica para borrar a todos los suscriptores es establecer someEvent como nulo agregando otro método público si desea exponer esta funcionalidad al exterior. Esto no tiene consecuencias no vistas. La condición previa es recordar declarar SomeEvent con la palabra clave 'evento'.

Consulte el libro - C # 4.0 en pocas palabras, página 125.

Alguien aquí propuso usar el método Delegate.RemoveAll . Si lo usa, el código de muestra podría seguir el siguiente formulario. Pero es realmente estúpido. ¿Por qué no solo SomeEvent=null dentro de la función ClearSubscribers() ?

   public void ClearSubscribers ()
    {
          SomeEvent = (EventHandler) Delegate.RemoveAll(SomeEvent, SomeEvent);// Then you will find SomeEvent is set to null.
    }



Esta es mi solución:

public class Foo : IDisposable
{
    private event EventHandler _statusChanged;
    public event EventHandler StatusChanged
    {
        add
        {
            _statusChanged += value;
        }
        remove
        {
            _statusChanged -= value;
        }
    }

    public void Dispose()
    {
        _statusChanged = null;
    }
}

using(new Foo()){/*...*/} llamar a Dispose() o usar el using(new Foo()){/*...*/} patrón using(new Foo()){/*...*/} para using(new Foo()){/*...*/} suscripción de todos los miembros de la lista de invocación.




Related