c# - vacio - Comprobando nulo antes de enviar el evento... ¿está seguro?

tag c#

Question

Algo que me confunde, pero que nunca ha causado ningún problema ... la forma recomendada de enviar un evento es la siguiente:

public event EventHandler SomeEvent;
...
{
    ....
    if(SomeEvent!=null)SomeEvent();
}

En un entorno de subprocesos múltiples, ¿cómo garantiza este código que otro subproceso no alterará la lista de invocación de SomeEvent entre la comprobación de nulo y la invocación del evento?

Answer 1

Como usted señala, cuando múltiples hilos pueden acceder a SomeEvent simultáneamente, un hilo podría verificar si SomeEvent es nulo y determinar que no lo es. Justo después de hacerlo, otro hilo podría eliminar el último delegado registrado de SomeEvent . Cuando el primer subproceso intenta subir SomeEvent , se SomeEvent una excepción. Una forma razonable de evitar este escenario es:

protected virtual void OnSomeEvent(EventArgs args) 
{
    EventHandler ev = SomeEvent;
    if (ev != null) ev(this, args);
}

Esto funciona porque cada vez que se agrega o quita un delegado de un evento utilizando las implementaciones predeterminadas de los accesadores de agregar y eliminar, se utilizan los métodos estáticos Delegate.Combine y Delegate.Remove. Cada uno de estos métodos devuelve una nueva instancia de un delegado, en lugar de modificar la que se le pasó.

Además, la asignación de una referencia de objeto en .NET es atomic , y las implementaciones predeterminadas de los accesos de evento de agregar y quitar están synchronised . Entonces, el código anterior tiene éxito copiando primero el delegado de multidifusión del evento a una variable temporal. Cualquier cambio en SomeEvent después de este punto no afectará la copia que haya realizado y almacenado. Por lo tanto, ahora puede comprobar de forma segura si los delegados se registraron y posteriormente invocarlos.

Tenga en cuenta que esta solución resuelve un problema de carrera, concretamente el de un controlador de eventos que es nulo cuando se invoca. No maneja el problema donde un controlador de eventos está extinto cuando se invoca, o un controlador de eventos se suscribe después de que se toma la copia.

Por ejemplo, si un controlador de eventos depende del estado que se destruye tan pronto como el controlador no está suscrito, esta solución podría invocar un código que no se puede ejecutar correctamente. Vea la excelente entrada del blog de Eric Lippert para más detalles. Además, vea esta pregunta y respuestas de .

EDITAR: Si estás usando C # 6.0, entonces la respuesta de Krzysztof parece una buena manera de hacerlo.

Answer 2

En C # 6.0, puede usar el operador monadic Null-conditional ?. para comprobar nulo y generar eventos de manera fácil y segura para la ejecución de subprocesos.

SomeEvent?.Invoke(this, args);

Es seguro para subprocesos porque evalúa el lado izquierdo solo una vez y lo mantiene en una variable temporal. Puede leer más here en la parte titulada Operadores Null-conditional.

Answer 3

La forma más sencilla de eliminar esta comprobación nula es asignar el manejador de eventos a un delegado anónimo. La multa incurrida en muy poco y lo libera de todos los controles nulos, condiciones de carrera, etc.

public event EventHandler SomeEvent = delegate {};

Pregunta relacionada: ¿Hay algún inconveniente en agregar un delegado vacío anónimo en una declaración de evento?

Answer 4

La forma recomendada es un poco diferente y utiliza un temporal de la siguiente manera:

EventHandler tmpEvent = SomeEvent;
if (tmpEvent != null)
{
    tmpEvent();
}

Answer 5

Me gustaría sugerir una ligera mejora en la respuesta de RoadWarrior al utilizar una función de extensión para EventHandler:

public static class Extensions
{
    public static void Raise(this EventHandler e, object sender, EventArgs args = null)
    {
        var e1 = e;

        if (e1 != null)
        {
            if (args == null)
                args = new EventArgs();

            e1(sender, args);
        }                
    }
  }

Con esta extensión en el alcance, los eventos pueden plantearse simplemente por:

clase SomeClass {evento público EventHandler MyEvent;

void SomeFunction()
{
    // code ...

    //---------------------------
    MyEvent.Raise(this);
    //---------------------------
}

}

c# events

Answer 6

Un enfoque más seguro:

public class Test
{
    private EventHandler myEvent;
    private object eventLock = new object();

    private void OnMyEvent()
    {
        EventHandler handler;

        lock(this.eventLock)
        {
            handler = this.myEvent;
        }
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    public event MyEvent
    {
        add
        {
            lock(this.eventLock)
            {
                this.myEvent += value;
            }
        }
        remove
        {
            lock(this.eventLock)
            {
                this.myEvent -= value;
            }
        }

    }
}

-cuenta