Tengo la siguiente clase, que tiene un evento público llamadoLengthChanged:

class Dimension
{
    public int Length
    {
        get
        {
            return this.length;
        }
        set
        {
            if (this.length != value)
            {
                this.length = value;
                this.OnLengthChanged ();
            }
    }

    protected virtual void OnLengthChanged()
    {
        var handler = this.LengthChanged;
        if (handler != null)
        {
            handler (this, System.EventArgs.Empty);
        }
    }

    public event System.EventHandler LengthChanged;

    private int length;
}

Me gustaría poder registrar / anular el registro de controladores para este evento en un método llamadoObserver, que no sabe nada sobre elDimension clase. Se me ocurrieron dos escenarios, ninguno de los cuales es realmente satisfactorio:

Definir una interfazILengthChanged con elLengthChanged evento, luego asegúreseDimension implementosILengthChanged. Luego tengo que proporcionar una implementación de laObserver Método para cada interfaz que defino. Esto de ninguna manera es lo suficientemente genérico. Realmente quiero poder simplemente pasar una referencia a unSystem.EventHandler evento.

UtilizarSystem.Action<System.EventHandler> devoluciones de llamada para registrar y anular el registro del controlador de eventos en elObserver método, así como así:

clase Foo {observador público vacío (System.Action register, System.Action unregister) {register (this.MyEventHandler);

    // keep track of the unregister callback, so that we can unregister
    // our event handler later on, if needed...
}

private void MyEventHandler(object sender, System.EventArgs e)
{
    ...
}

}

que luego se invocaría así:

Foo foo = ...;
Dimension dim = ...;

foo.Observer (x => dim.LengthChanged += x, x => dim.LengthChanged -= x);

y que, cuando se ejecuta, de hecho terminará cableando elLengthChanged evento con el controlador de eventos internoMyEventHandler. Pero esto no es muy elegante. Me hubiera encantado poder escribir esto:

Foo foo = ...;
Dimension dim = ...;

foo.Observer (dim.LengthChanged);

pero no tengo idea de cómo se podría lograr esto. Tal vez me estoy perdiendo algo realmente obvio aquí? Supongo que algunosdynamic la magia podría hacer el truco, de alguna manera, pero esto no exigiría la verificación de tipos en tiempo de compilación: no quiero que los usuarios deObserver para pasar referencias a eventos que no satisfacen elSystem.EventHandler firma del evento