Cómo convertir EventArgs cuando se cablean eventos?

Question

En aplicaciones .NET, normalmente eventos están conectados de esta manera:

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += value; } 
     remove { _dependency.OnChange -= value; } 
    } 

Sin embargo, esto sólo funciona si los eventos están cableados tienen el mismo controlador de eventos. En mi caso actual, el evento original args es propiedad de una biblioteca, y no quiero exponerlo al código del cliente. Entonces tengo algún tipo de adaptador (ChangeEventArgs). ¿Cómo puedo usar el código de arriba para convertir los argumentos del evento? Me imagino algo parecido a continuación (pero por debajo de código no funciona)

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += Convert(value); } 
     remove { _dependency.OnChange -= Convert(value); } 
    } 

o

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += value(this, Convert(args)); } 
     remove { _dependency.OnChange -= value(this, Convert(args)); } 
    } 

Answer 1

Prueba esto:

public class SomeClassAdapter 
{ 
    private readonly SomeClass obj; 

    public SomeClassAdapter(SomeClass obj) 
    { 
     this.obj = obj; 
     this.obj.SomeEvent += HandleSomeClassSomeEvent; 
    } 

    private void HandleSomeClassSomeEvent(object sender, SomeEventArgs args) 
    { 
     OnSomeEvent(ConvertEventArgs(args)); 
    } 

    private MyEventArgs ConvertEventArgs(SomeEventArgs args) 
    { 
     // the magic goes here... 
    } 

    protected virtual void OnSomeEvent(MyEventArgs args) 
    { 
     var handler = SomeEvent; 
     if (handler != null) 
     { 
      handler(this, args); 
     } 
    } 

    public event EventHandler<MyEventArgs> SomeEvent; 
} 

actualización.
Este código usa una versión más compleja del patrón de adaptador, que su código. SomeClassAdapter es un adaptador para SomeClass (tiene SomeClass instancia en su campo privado obj).

Código de cliente suscrito a miSomeClassAdapter.SomeEvent. Mi código, a su vez, se suscribe a SomeClass.SomeEvent. Cuando se dispara SomeClass.SomeEvent, se llama a mi controlador de eventos (HandleSomeClassSomeEvent). Este controlador de eventos convierte SomeEventArgs en MyEventArgs y aumenta SomeClassAdapter.SomeEvent.

Entonces, tenemos la cadena: SomeClass.SomeEvent ->HandleSomeClassSomeEvent ->SomeClassAdapter.SomeEvent. Parece "proxy de evento".

Answer 2

hay algunas cosas que hay que hacer aquí, me voy a asumir el tipo de retorno de su método de Convert() va a ser llamado SupportedChangeEventArgs

El patrón normal sería entonces tener:

public event EventHandler<SupportedChangeEventArgs> Changed; // per http://msdn.microsoft.com/en-us/library/h0eyck3s%28v=vs.71%29.aspx 

Agregar tiene un miembro virtual que genera el evento

public virtual void OnChanged(ChangeEventArgs e) 
{ 
    if(Changed != null) 
    { 
     Changed(this, Convert(e)); 
    } 
}